988 lines
19 KiB
JavaScript
988 lines
19 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var grammar = {
|
|
Name: {
|
|
token: 'Name'
|
|
},
|
|
String: {
|
|
token: 'String'
|
|
},
|
|
BlockString: {
|
|
token: 'BlockString'
|
|
},
|
|
Document: {
|
|
listOfType: 'Definition'
|
|
},
|
|
Definition: {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: 'Name',
|
|
oneOf: ['query', 'mutation', 'subscription']
|
|
},
|
|
expect: 'OperationDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
token: 'Name',
|
|
ofValue: 'fragment'
|
|
},
|
|
expect: 'FragmentDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
token: 'Name',
|
|
oneOf: ['schema', 'scalar', 'type', 'interface', 'union', 'enum', 'input', 'directive']
|
|
},
|
|
expect: 'TypeSystemDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
token: 'Name',
|
|
ofValue: 'extend'
|
|
},
|
|
expect: 'TypeSystemExtension'
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'OperationDefinition'
|
|
}, {
|
|
ifCondition: 'String',
|
|
expect: 'TypeSystemDefinition'
|
|
}, {
|
|
ifCondition: 'BlockString',
|
|
expect: 'TypeSystemDefinition'
|
|
}]
|
|
},
|
|
OperationDefinition: {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'SelectionSet'
|
|
}, {
|
|
ifCondition: {
|
|
token: 'Name',
|
|
oneOf: ['query', 'mutation', 'subscription']
|
|
},
|
|
expect: ['OperationType', {
|
|
token: 'Name',
|
|
optional: true,
|
|
tokenName: 'OperationName',
|
|
definitionName: true
|
|
}, {
|
|
ofType: 'VariableDefinitions',
|
|
optional: true
|
|
}, {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, 'SelectionSet']
|
|
}]
|
|
},
|
|
OperationType: {
|
|
ofType: 'OperationTypeName'
|
|
},
|
|
OperationTypeName: {
|
|
token: 'Name',
|
|
oneOf: ['query', 'mutation', 'subscription'],
|
|
definitionName: true
|
|
},
|
|
SelectionSet: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'Selection'
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
Selection: {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '...'
|
|
},
|
|
expect: 'Fragment'
|
|
}, {
|
|
ifCondition: {
|
|
token: 'Name'
|
|
},
|
|
expect: 'Field'
|
|
}]
|
|
},
|
|
Field: [{
|
|
ofType: 'Alias',
|
|
optional: true,
|
|
eatNextOnFail: true,
|
|
definitionName: true
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'FieldName',
|
|
definitionName: true
|
|
}, {
|
|
ofType: 'Arguments',
|
|
optional: true
|
|
}, {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
ofType: 'SelectionSet',
|
|
optional: true
|
|
}],
|
|
Arguments: [{
|
|
token: '('
|
|
}, {
|
|
listOfType: 'Argument'
|
|
}, {
|
|
token: ')'
|
|
}],
|
|
Argument: [{
|
|
token: 'Name',
|
|
tokenName: 'ArgumentName',
|
|
definitionName: true
|
|
}, {
|
|
token: ':'
|
|
}, 'Value'],
|
|
Alias: [{
|
|
token: 'Name',
|
|
tokenName: 'AliasName',
|
|
definitionName: true
|
|
}, {
|
|
token: ':'
|
|
}],
|
|
Fragment: [{
|
|
token: '...'
|
|
}, {
|
|
peek: [{
|
|
ifCondition: 'FragmentName',
|
|
expect: 'FragmentSpread'
|
|
}, {
|
|
ifCondition: {
|
|
token: 'Name',
|
|
ofValue: 'on'
|
|
},
|
|
expect: 'InlineFragment'
|
|
}, {
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: 'InlineFragment'
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'InlineFragment'
|
|
}]
|
|
}],
|
|
FragmentSpread: ['FragmentName', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}],
|
|
FragmentDefinition: [{
|
|
token: 'Name',
|
|
ofValue: 'fragment',
|
|
tokenName: 'FragmentDefinitionKeyword'
|
|
}, 'FragmentName', 'TypeCondition', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, 'SelectionSet'],
|
|
FragmentName: {
|
|
token: 'Name',
|
|
butNot: {
|
|
token: 'Name',
|
|
ofValue: 'on'
|
|
},
|
|
definitionName: true
|
|
},
|
|
TypeCondition: [{
|
|
token: 'Name',
|
|
ofValue: 'on',
|
|
tokenName: 'OnKeyword'
|
|
}, 'TypeName'],
|
|
InlineFragment: [{
|
|
ofType: 'TypeCondition',
|
|
optional: true
|
|
}, {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, 'SelectionSet'],
|
|
Value: {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '$'
|
|
},
|
|
expect: 'Variable'
|
|
}, {
|
|
ifCondition: 'IntValue',
|
|
expect: {
|
|
ofType: 'IntValue',
|
|
tokenName: 'NumberValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'FloatValue',
|
|
expect: {
|
|
ofType: 'FloatValue',
|
|
tokenName: 'NumberValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'BooleanValue',
|
|
expect: {
|
|
ofType: 'BooleanValue',
|
|
tokenName: 'BooleanValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'EnumValue',
|
|
expect: {
|
|
ofType: 'EnumValue',
|
|
tokenName: 'EnumValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'String',
|
|
expect: {
|
|
ofType: 'String',
|
|
tokenName: 'StringValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'BlockString',
|
|
expect: {
|
|
ofType: 'BlockString',
|
|
tokenName: 'StringValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'NullValue',
|
|
expect: {
|
|
ofType: 'NullValue',
|
|
tokenName: 'NullValue'
|
|
}
|
|
}, {
|
|
ifCondition: {
|
|
token: '['
|
|
},
|
|
expect: 'ListValue'
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'ObjectValue'
|
|
}]
|
|
},
|
|
ConstValue: {
|
|
peek: [{
|
|
ifCondition: 'IntValue',
|
|
expect: {
|
|
ofType: 'IntValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'FloatValue',
|
|
expect: {
|
|
ofType: 'FloatValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'BooleanValue',
|
|
expect: 'BooleanValue'
|
|
}, {
|
|
ifCondition: 'EnumValue',
|
|
expect: 'EnumValue'
|
|
}, {
|
|
ifCondition: 'String',
|
|
expect: {
|
|
ofType: 'String',
|
|
tokenName: 'StringValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'BlockString',
|
|
expect: {
|
|
token: 'BlockString',
|
|
tokenName: 'StringValue'
|
|
}
|
|
}, {
|
|
ifCondition: 'NullValue',
|
|
expect: 'NullValue'
|
|
}, {
|
|
ifCondition: {
|
|
token: '['
|
|
},
|
|
expect: 'ConstListValue'
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'ObjectValue'
|
|
}]
|
|
},
|
|
IntValue: {
|
|
token: 'Int'
|
|
},
|
|
FloatValue: {
|
|
token: 'Float'
|
|
},
|
|
StringValue: {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: 'String'
|
|
},
|
|
expect: {
|
|
token: 'String',
|
|
tokenName: 'StringValue'
|
|
}
|
|
}, {
|
|
ifCondition: {
|
|
token: 'BlockString'
|
|
},
|
|
expect: {
|
|
token: 'BlockString',
|
|
tokenName: 'StringValue'
|
|
}
|
|
}]
|
|
},
|
|
BooleanValue: {
|
|
token: 'Name',
|
|
oneOf: ['true', 'false'],
|
|
tokenName: 'BooleanValue'
|
|
},
|
|
NullValue: {
|
|
token: 'Name',
|
|
ofValue: 'null',
|
|
tokenName: 'NullValue'
|
|
},
|
|
EnumValue: {
|
|
token: 'Name',
|
|
butNot: {
|
|
token: 'Name',
|
|
oneOf: ['null', 'true', 'false']
|
|
},
|
|
tokenName: 'EnumValue'
|
|
},
|
|
ListValue: [{
|
|
token: '['
|
|
}, {
|
|
listOfType: 'Value',
|
|
optional: true
|
|
}, {
|
|
token: ']'
|
|
}],
|
|
ConstListValue: [{
|
|
token: '['
|
|
}, {
|
|
listOfType: 'ConstValue',
|
|
optional: true
|
|
}, {
|
|
token: ']'
|
|
}],
|
|
ObjectValue: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'ObjectField',
|
|
optional: true
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
ObjectField: [{
|
|
token: 'Name',
|
|
tokenName: 'ObjectFieldName'
|
|
}, {
|
|
token: ':'
|
|
}, {
|
|
ofType: 'ConstValue'
|
|
}],
|
|
Variable: [{
|
|
token: '$',
|
|
tokenName: 'VariableName'
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'VariableName'
|
|
}],
|
|
VariableDefinitions: [{
|
|
token: '('
|
|
}, {
|
|
listOfType: 'VariableDefinition'
|
|
}, {
|
|
token: ')'
|
|
}],
|
|
VariableDefinition: ['Variable', {
|
|
token: ':'
|
|
}, 'Type', {
|
|
ofType: 'DefaultValue',
|
|
optional: true
|
|
}],
|
|
DefaultValue: [{
|
|
token: '='
|
|
}, 'ConstValue'],
|
|
TypeName: {
|
|
token: 'Name',
|
|
tokenName: 'TypeName',
|
|
typeName: true
|
|
},
|
|
Type: {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: 'Name'
|
|
},
|
|
expect: ['TypeName', {
|
|
token: '!',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '['
|
|
},
|
|
expect: 'ListType'
|
|
}]
|
|
},
|
|
ListType: [{
|
|
token: '['
|
|
}, {
|
|
listOfType: 'Type'
|
|
}, {
|
|
token: ']'
|
|
}, {
|
|
token: '!',
|
|
optional: true
|
|
}],
|
|
Directives: {
|
|
listOfType: 'Directive'
|
|
},
|
|
Directive: [{
|
|
token: '@',
|
|
tokenName: 'DirectiveName'
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'DirectiveName'
|
|
}, {
|
|
ofType: 'Arguments',
|
|
optional: true
|
|
}],
|
|
TypeSystemDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
peek: [{
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'schema'
|
|
},
|
|
expect: 'SchemaDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'scalar'
|
|
},
|
|
expect: 'ScalarTypeDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'type'
|
|
},
|
|
expect: 'ObjectTypeDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'interface'
|
|
},
|
|
expect: 'InterfaceTypeDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'union'
|
|
},
|
|
expect: 'UnionTypeDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'enum'
|
|
},
|
|
expect: 'EnumTypeDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'input'
|
|
},
|
|
expect: 'InputObjectTypeDefinition'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'directive'
|
|
},
|
|
expect: 'DirectiveDefinition'
|
|
}]
|
|
}],
|
|
TypeSystemExtension: {
|
|
peek: [{
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'schema'
|
|
},
|
|
expect: 'SchemaExtension'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'scalar'
|
|
},
|
|
expect: 'ScalarTypeExtension'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'type'
|
|
},
|
|
expect: 'ObjectTypeExtension'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'interface'
|
|
},
|
|
expect: 'InterfaceTypeExtension'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'union'
|
|
},
|
|
expect: 'UnionTypeExtension'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'enum'
|
|
},
|
|
expect: 'EnumTypeExtension'
|
|
}, {
|
|
ifCondition: {
|
|
target: 'Name',
|
|
ofValue: 'input'
|
|
},
|
|
expect: 'InputObjectTypeExtension'
|
|
}]
|
|
},
|
|
SchemaDefinition: [{
|
|
token: 'Name',
|
|
ofValue: 'schema',
|
|
tokenName: 'SchemaDefinitionKeyword'
|
|
}, {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'RootOperationTypeDefinition'
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
RootOperationTypeDefinition: ['OperationType', {
|
|
token: ':'
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'OperationTypeDefinitionName'
|
|
}],
|
|
SchemaExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'schema'
|
|
}, 'Name', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'RootOperationTypeDefinition'
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'RootOperationTypeDefinition'
|
|
}, {
|
|
token: '}'
|
|
}]
|
|
}]
|
|
}],
|
|
Description: 'StringValue',
|
|
ScalarTypeDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'scalar',
|
|
tokenName: 'ScalarDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}],
|
|
ScalarTypeExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend',
|
|
tokenName: 'ExtendDefinitionKeyword'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'scalar',
|
|
tokenName: 'ScalarDefinitionKeyword'
|
|
}, 'TypeName', 'Directives'],
|
|
ObjectTypeDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'type',
|
|
tokenName: 'TypeDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
ofType: 'ImplementsInterfaces',
|
|
optional: true
|
|
}, {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
ofType: 'FieldsDefinition',
|
|
optional: true
|
|
}],
|
|
ImplementsInterfaces: [{
|
|
token: 'Name',
|
|
ofValue: 'implements',
|
|
tokenName: 'ImplementsKeyword'
|
|
}, {
|
|
token: '&',
|
|
optional: true
|
|
}, 'TypeName', {
|
|
listOfType: 'ImplementsAdditionalInterfaceName',
|
|
optional: true
|
|
}],
|
|
ImplementsAdditionalInterfaceName: [{
|
|
token: '&'
|
|
}, 'TypeName'],
|
|
FieldsDefinition: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'FieldDefinition'
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
FieldDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'AliasName',
|
|
definitionName: true
|
|
}, {
|
|
ofType: 'ArgumentsDefinition',
|
|
optional: true
|
|
}, {
|
|
token: ':'
|
|
}, 'Type', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}],
|
|
ArgumentsDefinition: [{
|
|
token: '('
|
|
}, {
|
|
listOfType: 'InputValueDefinition'
|
|
}, {
|
|
token: ')'
|
|
}],
|
|
InputValueDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'ArgumentName'
|
|
}, {
|
|
token: ':'
|
|
}, 'Type', {
|
|
ofType: 'DefaultValue',
|
|
optional: true
|
|
}, {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}],
|
|
ObjectTypeExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend',
|
|
tokenName: 'ExtendDefinitionKeyword'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'type',
|
|
tokenName: 'TypeDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: 'Name',
|
|
ofValue: 'interface'
|
|
},
|
|
expect: ['ImplementsInterfaces', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: 'FieldsDefinition',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'FieldsDefinition'
|
|
}],
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: 'FieldsDefinition',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'FieldsDefinition'
|
|
}]
|
|
}],
|
|
InterfaceTypeDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'interface',
|
|
tokenName: 'InterfaceDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
ofType: 'FieldsDefinition',
|
|
optional: true
|
|
}],
|
|
InterfaceTypeExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend',
|
|
tokenName: 'ExtendDefinitionKeyword'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'interface',
|
|
tokenName: 'InterfaceDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: 'FieldsDefinition',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'FieldsDefinition'
|
|
}]
|
|
}],
|
|
UnionTypeDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'union',
|
|
tokenName: 'UnionDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
ofType: 'UnionMemberTypes',
|
|
optional: true
|
|
}],
|
|
UnionMemberTypes: [{
|
|
token: '='
|
|
}, {
|
|
token: '|',
|
|
optional: true
|
|
}, 'Name', {
|
|
listOfType: 'UnionMemberAdditionalTypeName',
|
|
optional: true
|
|
}],
|
|
UnionMemberAdditionalTypeName: [{
|
|
token: '|'
|
|
}, 'TypeName'],
|
|
UnionTypeExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend',
|
|
tokenName: 'ExtendDefinitionKeyword'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'union',
|
|
tokenName: 'UnionDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: 'UnionMemberTypes',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '='
|
|
},
|
|
expect: 'UnionMemberTypes'
|
|
}]
|
|
}],
|
|
EnumTypeDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'enum',
|
|
tokenName: 'EnumDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
ofType: 'EnumValuesDefinition',
|
|
optional: true
|
|
}],
|
|
EnumValuesDefinition: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'EnumValueDefinition'
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
EnumValueDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, 'EnumValue', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}],
|
|
EnumTypeExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend',
|
|
tokenName: 'ExtendDefinitionKeyword'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'enum',
|
|
tokenName: 'EnumDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: 'EnumValuesDefinition',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'EnumValuesDefinition'
|
|
}]
|
|
}],
|
|
InputObjectTypeDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'input',
|
|
tokenName: 'InputDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
ofType: 'Directives',
|
|
optional: true
|
|
}, {
|
|
ofType: 'InputFieldsDefinition',
|
|
optional: true
|
|
}],
|
|
InputFieldsDefinition: [{
|
|
token: '{'
|
|
}, {
|
|
listOfType: 'InputValueDefinition'
|
|
}, {
|
|
token: '}'
|
|
}],
|
|
InputObjectTypeExtension: [{
|
|
token: 'Name',
|
|
ofValue: 'extend',
|
|
tokenName: 'ExtendDefinitionKeyword'
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'input',
|
|
tokenName: 'InputDefinitionKeyword'
|
|
}, 'TypeName', {
|
|
peek: [{
|
|
ifCondition: {
|
|
token: '@'
|
|
},
|
|
expect: ['Directives', {
|
|
ofType: 'InputFieldsDefinition',
|
|
optional: true
|
|
}]
|
|
}, {
|
|
ifCondition: {
|
|
token: '{'
|
|
},
|
|
expect: 'InputFieldsDefinition'
|
|
}]
|
|
}],
|
|
DirectiveDefinition: [{
|
|
ofType: 'Description',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'directive',
|
|
tokenName: 'DirectiveDefinitionKeyword'
|
|
}, {
|
|
token: '@',
|
|
tokenName: 'DirectiveName'
|
|
}, {
|
|
token: 'Name',
|
|
tokenName: 'DirectiveName'
|
|
}, {
|
|
ofType: 'ArgumentsDefinition',
|
|
optional: true
|
|
}, {
|
|
token: 'Name',
|
|
ofValue: 'on',
|
|
tokenName: 'OnKeyword'
|
|
}, 'DirectiveLocations'],
|
|
DirectiveLocations: [{
|
|
token: '|',
|
|
optional: true
|
|
}, 'DirectiveLocation', {
|
|
listOfType: 'DirectiveLocationAdditionalName',
|
|
optional: true
|
|
}],
|
|
DirectiveLocationAdditionalName: [{
|
|
token: '|'
|
|
}, 'DirectiveLocation'],
|
|
DirectiveLocation: {
|
|
peek: [{
|
|
ifCondition: 'ExecutableDirectiveLocation',
|
|
expect: 'ExecutableDirectiveLocation'
|
|
}, {
|
|
ifCondition: 'TypeSystemDirectiveLocation',
|
|
expect: 'TypeSystemDirectiveLocation'
|
|
}]
|
|
},
|
|
ExecutableDirectiveLocation: {
|
|
token: 'Name',
|
|
oneOf: ['QUERY', 'MUTATION', 'SUBSCRIPTION', 'FIELD', 'FRAGMENT_DEFINITION', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'],
|
|
tokenName: 'EnumValue'
|
|
},
|
|
TypeSystemDirectiveLocation: {
|
|
token: 'Name',
|
|
oneOf: ['SCHEMA', 'SCALAR', 'OBJECT', 'FIELD_DEFINITION', 'ARGUMENT_DEFINITION', 'INTERFACE', 'UNION', 'ENUM', 'ENUM_VALUE', 'INPUT_OBJECT', 'INPUT_FIELD_DEFINITION'],
|
|
tokenName: 'EnumValue'
|
|
} // FIXME: enforce proper typing
|
|
|
|
};
|
|
var _default = grammar;
|
|
exports.default = _default;
|