swc/crates/swc_bundler/tests/.cache/deno/c6b66edb91ebd6db54ce6aa59b21f51319c5c7fa.ts

256 lines
7.4 KiB
TypeScript
Raw Normal View History

// Loaded from https://deno.land/x/graphql_deno@v15.0.0/lib/language/printer.js
import { visit } from './visitor.js';
import { printBlockString } from './blockString.js';
/**
* Converts an AST into a string, using one set of reasonable
* formatting rules.
*/
export function print(ast) {
return visit(ast, {
leave: printDocASTReducer
});
} // TODO: provide better type coverage in future
const printDocASTReducer = {
Name: node => node.value,
Variable: node => '$' + node.name,
// Document
Document: node => join(node.definitions, '\n\n') + '\n',
OperationDefinition(node) {
const op = node.operation;
const name = node.name;
const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
const directives = join(node.directives, ' ');
const selectionSet = node.selectionSet; // Anonymous queries with no directives or variable definitions can use
// the query short form.
return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
},
VariableDefinition: ({
variable,
type,
defaultValue,
directives
}) => variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' ')),
SelectionSet: ({
selections
}) => block(selections),
Field: ({
alias,
name,
arguments: args,
directives,
selectionSet
}) => join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' '),
Argument: ({
name,
value
}) => name + ': ' + value,
// Fragments
FragmentSpread: ({
name,
directives
}) => '...' + name + wrap(' ', join(directives, ' ')),
InlineFragment: ({
typeCondition,
directives,
selectionSet
}) => join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' '),
FragmentDefinition: ({
name,
typeCondition,
variableDefinitions,
directives,
selectionSet
}) => // Note: fragment variable definitions are experimental and may be changed
// or removed in the future.
`fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` + `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` + selectionSet,
// Value
IntValue: ({
value
}) => value,
FloatValue: ({
value
}) => value,
StringValue: ({
value,
block: isBlockString
}, key) => isBlockString ? printBlockString(value, key === 'description' ? '' : ' ') : JSON.stringify(value),
BooleanValue: ({
value
}) => value ? 'true' : 'false',
NullValue: () => 'null',
EnumValue: ({
value
}) => value,
ListValue: ({
values
}) => '[' + join(values, ', ') + ']',
ObjectValue: ({
fields
}) => '{' + join(fields, ', ') + '}',
ObjectField: ({
name,
value
}) => name + ': ' + value,
// Directive
Directive: ({
name,
arguments: args
}) => '@' + name + wrap('(', join(args, ', '), ')'),
// Type
NamedType: ({
name
}) => name,
ListType: ({
type
}) => '[' + type + ']',
NonNullType: ({
type
}) => type + '!',
// Type System Definitions
SchemaDefinition: addDescription(({
directives,
operationTypes
}) => join(['schema', join(directives, ' '), block(operationTypes)], ' ')),
OperationTypeDefinition: ({
operation,
type
}) => operation + ': ' + type,
ScalarTypeDefinition: addDescription(({
name,
directives
}) => join(['scalar', name, join(directives, ' ')], ' ')),
ObjectTypeDefinition: addDescription(({
name,
interfaces,
directives,
fields
}) => join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ')),
FieldDefinition: addDescription(({
name,
arguments: args,
type,
directives
}) => name + (hasMultilineItems(args) ? wrap('(\n', indent(join(args, '\n')), '\n)') : wrap('(', join(args, ', '), ')')) + ': ' + type + wrap(' ', join(directives, ' '))),
InputValueDefinition: addDescription(({
name,
type,
defaultValue,
directives
}) => join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ')),
InterfaceTypeDefinition: addDescription(({
name,
interfaces,
directives,
fields
}) => join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ')),
UnionTypeDefinition: addDescription(({
name,
directives,
types
}) => join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ')),
EnumTypeDefinition: addDescription(({
name,
directives,
values
}) => join(['enum', name, join(directives, ' '), block(values)], ' ')),
EnumValueDefinition: addDescription(({
name,
directives
}) => join([name, join(directives, ' ')], ' ')),
InputObjectTypeDefinition: addDescription(({
name,
directives,
fields
}) => join(['input', name, join(directives, ' '), block(fields)], ' ')),
DirectiveDefinition: addDescription(({
name,
arguments: args,
repeatable,
locations
}) => 'directive @' + name + (hasMultilineItems(args) ? wrap('(\n', indent(join(args, '\n')), '\n)') : wrap('(', join(args, ', '), ')')) + (repeatable ? ' repeatable' : '') + ' on ' + join(locations, ' | ')),
SchemaExtension: ({
directives,
operationTypes
}) => join(['extend schema', join(directives, ' '), block(operationTypes)], ' '),
ScalarTypeExtension: ({
name,
directives
}) => join(['extend scalar', name, join(directives, ' ')], ' '),
ObjectTypeExtension: ({
name,
interfaces,
directives,
fields
}) => join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
InterfaceTypeExtension: ({
name,
interfaces,
directives,
fields
}) => join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
UnionTypeExtension: ({
name,
directives,
types
}) => join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' '),
EnumTypeExtension: ({
name,
directives,
values
}) => join(['extend enum', name, join(directives, ' '), block(values)], ' '),
InputObjectTypeExtension: ({
name,
directives,
fields
}) => join(['extend input', name, join(directives, ' '), block(fields)], ' ')
};
function addDescription(cb) {
return node => join([node.description, cb(node)], '\n');
}
/**
* Given maybeArray, print an empty string if it is null or empty, otherwise
* print all items together separated by separator if provided
*/
function join(maybeArray, separator = '') {
return maybeArray?.filter(x => x).join(separator) ?? '';
}
/**
* Given array, print each item on its own line, wrapped in an
* indented "{ }" block.
*/
function block(array) {
return array && array.length !== 0 ? '{\n' + indent(join(array, '\n')) + '\n}' : '';
}
/**
* If maybeString is not null or empty, then wrap with start and end, otherwise
* print an empty string.
*/
function wrap(start, maybeString, end = '') {
return maybeString ? start + maybeString + end : '';
}
function indent(maybeString) {
return maybeString && ' ' + maybeString.replace(/\n/g, '\n ');
}
function isMultiline(string) {
return string.indexOf('\n') !== -1;
}
function hasMultilineItems(maybeArray) {
return maybeArray && maybeArray.some(isMultiline);
}