graphql 15.10.2 → 15.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (99) hide show
  1. package/error/GraphQLError.js +7 -6
  2. package/error/GraphQLError.js.flow +3 -3
  3. package/error/GraphQLError.mjs +8 -7
  4. package/execution/execute.d.ts +2 -0
  5. package/execution/execute.js +33 -12
  6. package/execution/execute.js.flow +32 -11
  7. package/execution/execute.mjs +33 -12
  8. package/execution/values.d.ts +1 -1
  9. package/execution/values.js +5 -5
  10. package/execution/values.js.flow +5 -2
  11. package/execution/values.mjs +4 -4
  12. package/graphql.d.ts +1 -0
  13. package/graphql.js +4 -1
  14. package/graphql.js.flow +5 -1
  15. package/graphql.mjs +4 -1
  16. package/jsutils/SetMap.js +56 -0
  17. package/jsutils/SetMap.js.flow +39 -0
  18. package/jsutils/SetMap.mjs +47 -0
  19. package/language/lexer.js +21 -2
  20. package/language/lexer.js.flow +24 -2
  21. package/language/lexer.mjs +21 -2
  22. package/language/location.d.ts +5 -0
  23. package/language/location.js +64 -0
  24. package/language/location.js.flow +39 -0
  25. package/language/location.mjs +62 -0
  26. package/language/parser.js +34 -19
  27. package/language/parser.js.flow +54 -10
  28. package/language/parser.mjs +34 -19
  29. package/language/printer.d.ts +7 -0
  30. package/language/printer.js +251 -118
  31. package/language/printer.js.flow +345 -141
  32. package/language/printer.mjs +246 -116
  33. package/language/reducer.js +99 -0
  34. package/language/reducer.js.flow +89 -0
  35. package/language/reducer.mjs +89 -0
  36. package/package.json +1 -4
  37. package/subscription/subscribe.d.ts +2 -0
  38. package/subscription/subscribe.js +4 -3
  39. package/subscription/subscribe.js.flow +6 -0
  40. package/subscription/subscribe.mjs +4 -3
  41. package/type/definition.d.ts +2 -1
  42. package/type/definition.js +8 -8
  43. package/type/definition.js.flow +13 -7
  44. package/type/definition.mjs +7 -7
  45. package/type/scalars.js +5 -5
  46. package/type/scalars.js.flow +1 -1
  47. package/type/scalars.mjs +1 -1
  48. package/utilities/buildASTSchema.js +3 -0
  49. package/utilities/buildASTSchema.js.flow +3 -0
  50. package/utilities/buildASTSchema.mjs +3 -0
  51. package/utilities/coerceInputValue.d.ts +1 -0
  52. package/utilities/coerceInputValue.js +9 -8
  53. package/utilities/coerceInputValue.js.flow +42 -9
  54. package/utilities/coerceInputValue.mjs +10 -9
  55. package/utilities/findBreakingChanges.js +3 -23
  56. package/utilities/findBreakingChanges.js.flow +2 -15
  57. package/utilities/findBreakingChanges.mjs +2 -21
  58. package/utilities/sortValueNode.js +52 -0
  59. package/utilities/sortValueNode.js.flow +42 -0
  60. package/utilities/sortValueNode.mjs +42 -0
  61. package/utilities/valueFromAST.js +2 -2
  62. package/utilities/valueFromAST.js.flow +8 -2
  63. package/utilities/valueFromAST.mjs +2 -2
  64. package/validation/ValidationContext.d.ts +8 -0
  65. package/validation/ValidationContext.js +82 -24
  66. package/validation/ValidationContext.js.flow +70 -21
  67. package/validation/ValidationContext.mjs +80 -24
  68. package/validation/rules/FieldsOnCorrectTypeRule.js +2 -2
  69. package/validation/rules/FieldsOnCorrectTypeRule.js.flow +8 -2
  70. package/validation/rules/FieldsOnCorrectTypeRule.mjs +2 -2
  71. package/validation/rules/KnownArgumentNamesRule.js +8 -9
  72. package/validation/rules/KnownArgumentNamesRule.js.flow +16 -6
  73. package/validation/rules/KnownArgumentNamesRule.mjs +8 -9
  74. package/validation/rules/KnownTypeNamesRule.js +1 -1
  75. package/validation/rules/KnownTypeNamesRule.js.flow +6 -4
  76. package/validation/rules/KnownTypeNamesRule.mjs +1 -1
  77. package/validation/rules/MaxIntrospectionDepthRule.js +37 -17
  78. package/validation/rules/MaxIntrospectionDepthRule.js.flow +46 -15
  79. package/validation/rules/MaxIntrospectionDepthRule.mjs +37 -17
  80. package/validation/rules/NoUnusedFragmentsRule.js +6 -13
  81. package/validation/rules/NoUnusedFragmentsRule.js.flow +6 -10
  82. package/validation/rules/NoUnusedFragmentsRule.mjs +6 -13
  83. package/validation/rules/OverlappingFieldsCanBeMergedRule.js +402 -208
  84. package/validation/rules/OverlappingFieldsCanBeMergedRule.js.flow +566 -330
  85. package/validation/rules/OverlappingFieldsCanBeMergedRule.mjs +400 -206
  86. package/validation/rules/ValuesOfCorrectTypeRule.js +6 -6
  87. package/validation/rules/ValuesOfCorrectTypeRule.js.flow +11 -6
  88. package/validation/rules/ValuesOfCorrectTypeRule.mjs +4 -4
  89. package/validation/validate.d.ts +1 -1
  90. package/validation/validate.js +6 -2
  91. package/validation/validate.js.flow +8 -2
  92. package/validation/validate.mjs +5 -2
  93. package/validation/validationAbortedError.d.ts +4 -0
  94. package/validation/validationAbortedError.js +12 -0
  95. package/validation/validationAbortedError.js.flow +7 -0
  96. package/validation/validationAbortedError.mjs +4 -0
  97. package/version.js +3 -3
  98. package/version.js.flow +3 -3
  99. package/version.mjs +3 -3
@@ -1,66 +1,171 @@
1
1
  // @flow strict
2
- import type { ASTNode } from './ast';
2
+ /** @category Printing */
3
3
 
4
- import { visit } from './visitor';
4
+ import type { ASTNode } from './ast';
5
5
  import { printBlockString } from './blockString';
6
+ import { reduce } from './reducer';
7
+
8
+ type Maybe<+T> = ?T;
6
9
 
7
10
  /**
8
- * Converts an AST into a string, using one set of reasonable
9
- * formatting rules.
11
+ * Converts an AST into a string. Indentation and inserted newlines can be
12
+ * limited with maxIndentDepth; the default is unlimited.
10
13
  */
11
- export function print(ast: ASTNode): string {
12
- return visit(ast, { leave: printDocASTReducer });
14
+ declare function print(
15
+ ast: ASTNode,
16
+ options: { maxIndentDepth?: number, ... },
17
+ ): string;
18
+ // eslint-disable-next-line no-redeclare
19
+ declare function print(ast: ASTNode): string;
20
+ // eslint-disable-next-line no-redeclare
21
+ export function print(ast, options) {
22
+ return render(
23
+ reduce(ast, printDocASTReducer),
24
+ options?.maxIndentDepth ?? Infinity,
25
+ );
13
26
  }
14
27
 
28
+ /** @internal */
29
+ export function printForError(ast: ASTNode): string {
30
+ return print(ast, { maxIndentDepth: 100 });
31
+ }
32
+
33
+ // The wrapping limit applies to total string length, including newlines.
15
34
  const MAX_LINE_LENGTH = 80;
16
35
 
17
- // TODO: provide better type coverage in future
36
+ class PrintBuffer {
37
+ length: number;
38
+ newlines: number;
39
+ lines: string | $ReadOnlyArray<string>;
40
+ next: PrintBuffer | void;
41
+ tail: PrintBuffer | void;
42
+ indentBefore: boolean;
43
+ dedentAfter: boolean;
44
+ isBlockString: boolean;
45
+
46
+ constructor(value = '', isBlockString = false) {
47
+ this.next = undefined;
48
+ this.indentBefore = false;
49
+ this.dedentAfter = false;
50
+ this.length = value.length;
51
+ this.lines = value.includes('\n') ? value.split('\n') : value;
52
+ this.newlines = typeof this.lines === 'string' ? 0 : this.lines.length - 1;
53
+ this.isBlockString = isBlockString;
54
+ this.tail = undefined;
55
+ }
56
+
57
+ append(result: string | PrintBuffer): this {
58
+ if (result.length === 0) {
59
+ return this;
60
+ }
61
+ const next = typeof result === 'string' ? new PrintBuffer(result) : result;
62
+ (this.tail ?? this).next = next;
63
+ this.tail = next.tail ?? next;
64
+ this.length += next.length;
65
+ this.newlines += next.newlines;
66
+ return this;
67
+ }
68
+
69
+ indent(): this {
70
+ if (this.length === 0) {
71
+ return this;
72
+ }
73
+ this.indentBefore = true;
74
+ (this.tail ?? this).dedentAfter = true;
75
+ this.length += 2 * (this.newlines + 1);
76
+ return this;
77
+ }
78
+ }
79
+
80
+ const EMPTY = new PrintBuffer();
81
+
82
+ function render(buffer: PrintBuffer, maxDepth: number): string {
83
+ let output = '';
84
+ let text = '';
85
+ let depth = 0;
86
+ let indentation = '';
87
+ let part: PrintBuffer | void = buffer;
88
+ while (part !== undefined) {
89
+ const lines = part.lines;
90
+ if (part.indentBefore) {
91
+ if (depth < maxDepth) {
92
+ indentation += ' ';
93
+ text += ' ';
94
+ }
95
+ depth++;
96
+ }
97
+ if (typeof lines === 'string') {
98
+ text += lines;
99
+ } else {
100
+ text += lines[0];
101
+ const newline =
102
+ !part.isBlockString && depth >= maxDepth ? ' ' : '\n' + indentation;
103
+ for (let i = 1; i < lines.length; i++) {
104
+ output += text;
105
+ text = newline + lines[i];
106
+ }
107
+ }
108
+ if (part.dedentAfter) {
109
+ depth--;
110
+ indentation = indentation.slice(0, depth * 2);
111
+ }
112
+ part = part.next;
113
+ }
114
+ return output + text;
115
+ }
116
+
18
117
  const printDocASTReducer: any = {
19
- Name: (node) => node.value,
20
- Variable: (node) => '$' + node.name,
118
+ Name: (node) => new PrintBuffer(node.value),
119
+ Variable: (node) => join(['$', node.name]),
21
120
 
22
121
  // Document
23
122
 
24
- Document: (node) => join(node.definitions, '\n\n') + '\n',
123
+ Document: (node) => join([join(node.definitions, '\n\n'), '\n']),
25
124
 
26
125
  OperationDefinition(node) {
27
- const op = node.operation;
28
- const name = node.name;
29
126
  const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
30
127
  const directives = join(node.directives, ' ');
31
- const selectionSet = node.selectionSet;
32
- // Anonymous queries with no directives or variable definitions can use
33
- // the query short form.
34
- return !name && !directives && !varDefs && op === 'query'
35
- ? selectionSet
36
- : join([op, join([name, varDefs]), directives, selectionSet], ' ');
128
+ return !node.name &&
129
+ directives.length === 0 &&
130
+ varDefs.length === 0 &&
131
+ node.operation === 'query'
132
+ ? node.selectionSet
133
+ : join(
134
+ [
135
+ node.operation,
136
+ join([node.name, varDefs]),
137
+ directives,
138
+ node.selectionSet,
139
+ ],
140
+ ' ',
141
+ );
37
142
  },
38
143
 
39
144
  VariableDefinition: ({ variable, type, defaultValue, directives }) =>
40
- variable +
41
- ': ' +
42
- type +
43
- wrap(' = ', defaultValue) +
44
- wrap(' ', join(directives, ' ')),
145
+ join([
146
+ variable,
147
+ ': ',
148
+ type,
149
+ wrap(' = ', defaultValue),
150
+ wrap(' ', join(directives, ' ')),
151
+ ]),
45
152
  SelectionSet: ({ selections }) => block(selections),
46
153
 
47
- Field: ({ alias, name, arguments: args, directives, selectionSet }) => {
48
- const prefix = wrap('', alias, ': ') + name;
49
- let argsLine = prefix + wrap('(', join(args, ', '), ')');
50
-
51
- if (argsLine.length > MAX_LINE_LENGTH) {
52
- argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
53
- }
154
+ Field({ alias, name, arguments: args, directives, selectionSet }) {
155
+ const prefix = join([wrap('', alias, ': '), name], '');
54
156
 
55
- return join([argsLine, join(directives, ' '), selectionSet], ' ');
157
+ return join([
158
+ wrappedLineAndArgs(prefix, args),
159
+ wrap(' ', join(directives, ' ')),
160
+ wrap(' ', selectionSet),
161
+ ]);
56
162
  },
57
-
58
- Argument: ({ name, value }) => name + ': ' + value,
163
+ Argument: ({ name, value }) => join([name, ': ', value]),
59
164
 
60
165
  // Fragments
61
166
 
62
167
  FragmentSpread: ({ name, directives }) =>
63
- '...' + name + wrap(' ', join(directives, ' ')),
168
+ join(['...', name, wrap(' ', join(directives, ' '))]),
64
169
 
65
170
  InlineFragment: ({ typeCondition, directives, selectionSet }) =>
66
171
  join(
@@ -75,52 +180,74 @@ const printDocASTReducer: any = {
75
180
  directives,
76
181
  selectionSet,
77
182
  }) =>
78
- // Note: fragment variable definitions are experimental and may be changed
79
- // or removed in the future.
80
- `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +
81
- `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +
82
- selectionSet,
183
+ join([
184
+ // Note: fragment variable definitions are experimental and may be changed
185
+ // or removed in the future.
186
+ 'fragment ',
187
+ name,
188
+ wrap('(', join(variableDefinitions, ', '), ')'),
189
+ ' on ',
190
+ typeCondition,
191
+ ' ',
192
+ wrap('', join(directives, ' '), ' '),
193
+ selectionSet,
194
+ ]),
83
195
 
84
196
  // Value
85
197
 
86
- IntValue: ({ value }) => value,
87
- FloatValue: ({ value }) => value,
198
+ IntValue: ({ value }) => new PrintBuffer(value),
199
+ FloatValue: ({ value }) => new PrintBuffer(value),
88
200
  StringValue: ({ value, block: isBlockString }, key) =>
89
- isBlockString
90
- ? printBlockString(value, key === 'description' ? '' : ' ')
91
- : JSON.stringify(value),
92
- BooleanValue: ({ value }) => (value ? 'true' : 'false'),
93
- NullValue: () => 'null',
94
- EnumValue: ({ value }) => value,
95
- ListValue: ({ values }) => '[' + join(values, ', ') + ']',
96
- ObjectValue: ({ fields }) => '{' + join(fields, ', ') + '}',
97
- ObjectField: ({ name, value }) => name + ': ' + value,
201
+ new PrintBuffer(
202
+ isBlockString === true
203
+ ? printBlockString(value, key === 'description' ? '' : ' ')
204
+ : JSON.stringify(value),
205
+ isBlockString === true,
206
+ ),
207
+ BooleanValue: ({ value }) => new PrintBuffer(value ? 'true' : 'false'),
208
+ NullValue: () => new PrintBuffer('null'),
209
+ EnumValue: ({ value }) => new PrintBuffer(value),
210
+ ListValue: ({ values }) => join(['[', join(values, ', '), ']']),
211
+ ObjectValue: ({ fields }) => join(['{', join(fields, ', '), '}']),
212
+ ObjectField: ({ name, value }) => join([name, ': ', value]),
98
213
 
99
214
  // Directive
100
215
 
101
216
  Directive: ({ name, arguments: args }) =>
102
- '@' + name + wrap('(', join(args, ', '), ')'),
217
+ join(['@', name, wrap('(', join(args, ', '), ')')]),
103
218
 
104
219
  // Type
105
220
 
106
221
  NamedType: ({ name }) => name,
107
- ListType: ({ type }) => '[' + type + ']',
108
- NonNullType: ({ type }) => type + '!',
222
+ ListType: ({ type }) => join(['[', type, ']']),
223
+ NonNullType: ({ type }) => join([type, '!']),
109
224
 
110
225
  // Type System Definitions
111
226
 
112
- SchemaDefinition: addDescription(({ directives, operationTypes }) =>
113
- join(['schema', join(directives, ' '), block(operationTypes)], ' '),
114
- ),
227
+ SchemaDefinition: ({ description, directives, operationTypes }) =>
228
+ join([
229
+ wrap('', description, '\n'),
230
+ join(['schema', join(directives, ' '), block(operationTypes)], ' '),
231
+ ]),
115
232
 
116
- OperationTypeDefinition: ({ operation, type }) => operation + ': ' + type,
233
+ OperationTypeDefinition: ({ operation, type }) =>
234
+ join([operation, ': ', type]),
117
235
 
118
- ScalarTypeDefinition: addDescription(({ name, directives }) =>
119
- join(['scalar', name, join(directives, ' ')], ' '),
120
- ),
236
+ ScalarTypeDefinition: ({ description, name, directives }) =>
237
+ join([
238
+ wrap('', description, '\n'),
239
+ join(['scalar', name, join(directives, ' ')], ' '),
240
+ ]),
121
241
 
122
- ObjectTypeDefinition: addDescription(
123
- ({ name, interfaces, directives, fields }) =>
242
+ ObjectTypeDefinition: ({
243
+ description,
244
+ name,
245
+ interfaces,
246
+ directives,
247
+ fields,
248
+ }) =>
249
+ join([
250
+ wrap('', description, '\n'),
124
251
  join(
125
252
  [
126
253
  'type',
@@ -131,29 +258,45 @@ const printDocASTReducer: any = {
131
258
  ],
132
259
  ' ',
133
260
  ),
134
- ),
135
-
136
- FieldDefinition: addDescription(
137
- ({ name, arguments: args, type, directives }) =>
138
- name +
139
- (hasMultilineItems(args)
140
- ? wrap('(\n', indent(join(args, '\n')), '\n)')
141
- : wrap('(', join(args, ', '), ')')) +
142
- ': ' +
143
- type +
261
+ ]),
262
+
263
+ FieldDefinition: ({ description, name, arguments: args, type, directives }) =>
264
+ join([
265
+ wrap('', description, '\n'),
266
+ name,
267
+ hasMultilineItems(args)
268
+ ? wrap('(\n', join(args, '\n').indent(), '\n)')
269
+ : wrap('(', join(args, ', '), ')'),
270
+ ': ',
271
+ type,
144
272
  wrap(' ', join(directives, ' ')),
145
- ),
273
+ ]),
146
274
 
147
- InputValueDefinition: addDescription(
148
- ({ name, type, defaultValue, directives }) =>
149
- join(
150
- [name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')],
151
- ' ',
152
- ),
153
- ),
275
+ InputValueDefinition: ({
276
+ description,
277
+ name,
278
+ type,
279
+ defaultValue,
280
+ directives,
281
+ }) =>
282
+ join([
283
+ wrap('', description, '\n'),
284
+ name,
285
+ ': ',
286
+ type,
287
+ wrap(' = ', defaultValue),
288
+ wrap(' ', join(directives, ' ')),
289
+ ]),
154
290
 
155
- InterfaceTypeDefinition: addDescription(
156
- ({ name, interfaces, directives, fields }) =>
291
+ InterfaceTypeDefinition: ({
292
+ description,
293
+ name,
294
+ interfaces,
295
+ directives,
296
+ fields,
297
+ }) =>
298
+ join([
299
+ wrap('', description, '\n'),
157
300
  join(
158
301
  [
159
302
  'interface',
@@ -164,43 +307,53 @@ const printDocASTReducer: any = {
164
307
  ],
165
308
  ' ',
166
309
  ),
167
- ),
310
+ ]),
168
311
 
169
- UnionTypeDefinition: addDescription(({ name, directives, types }) =>
170
- join(
171
- [
172
- 'union',
173
- name,
174
- join(directives, ' '),
175
- types && types.length !== 0 ? '= ' + join(types, ' | ') : '',
176
- ],
177
- ' ',
178
- ),
179
- ),
180
-
181
- EnumTypeDefinition: addDescription(({ name, directives, values }) =>
182
- join(['enum', name, join(directives, ' '), block(values)], ' '),
183
- ),
184
-
185
- EnumValueDefinition: addDescription(({ name, directives }) =>
186
- join([name, join(directives, ' ')], ' '),
187
- ),
188
-
189
- InputObjectTypeDefinition: addDescription(({ name, directives, fields }) =>
190
- join(['input', name, join(directives, ' '), block(fields)], ' '),
191
- ),
192
-
193
- DirectiveDefinition: addDescription(
194
- ({ name, arguments: args, repeatable, locations }) =>
195
- 'directive @' +
196
- name +
197
- (hasMultilineItems(args)
198
- ? wrap('(\n', indent(join(args, '\n')), '\n)')
199
- : wrap('(', join(args, ', '), ')')) +
200
- (repeatable ? ' repeatable' : '') +
201
- ' on ' +
312
+ UnionTypeDefinition: ({ description, name, directives, types }) =>
313
+ join([
314
+ wrap('', description, '\n'),
315
+ join(
316
+ ['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))],
317
+ ' ',
318
+ ),
319
+ ]),
320
+
321
+ EnumTypeDefinition: ({ description, name, directives, values }) =>
322
+ join([
323
+ wrap('', description, '\n'),
324
+ join(['enum', name, join(directives, ' '), block(values)], ' '),
325
+ ]),
326
+
327
+ EnumValueDefinition: ({ description, name, directives }) =>
328
+ join([
329
+ wrap('', description, '\n'),
330
+ join([name, join(directives, ' ')], ' '),
331
+ ]),
332
+
333
+ InputObjectTypeDefinition: ({ description, name, directives, fields }) =>
334
+ join([
335
+ wrap('', description, '\n'),
336
+ join(['input', name, join(directives, ' '), block(fields)], ' '),
337
+ ]),
338
+
339
+ DirectiveDefinition: ({
340
+ description,
341
+ name,
342
+ arguments: args,
343
+ repeatable,
344
+ locations,
345
+ }) =>
346
+ join([
347
+ wrap('', description, '\n'),
348
+ 'directive @',
349
+ name,
350
+ hasMultilineItems(args)
351
+ ? wrap('(\n', join(args, '\n').indent(), '\n)')
352
+ : wrap('(', join(args, ', '), ')'),
353
+ repeatable ? ' repeatable' : '',
354
+ ' on ',
202
355
  join(locations, ' | '),
203
- ),
356
+ ]),
204
357
 
205
358
  SchemaExtension: ({ directives, operationTypes }) =>
206
359
  join(['extend schema', join(directives, ' '), block(operationTypes)], ' '),
@@ -238,7 +391,7 @@ const printDocASTReducer: any = {
238
391
  'extend union',
239
392
  name,
240
393
  join(directives, ' '),
241
- types && types.length !== 0 ? '= ' + join(types, ' | ') : '',
394
+ wrap('= ', join(types, ' | ')),
242
395
  ],
243
396
  ' ',
244
397
  ),
@@ -250,43 +403,94 @@ const printDocASTReducer: any = {
250
403
  join(['extend input', name, join(directives, ' '), block(fields)], ' '),
251
404
  };
252
405
 
253
- function addDescription(cb) {
254
- return (node) => join([node.description, cb(node)], '\n');
255
- }
256
-
257
406
  /**
258
407
  * Given maybeArray, print an empty string if it is null or empty, otherwise
259
408
  * print all items together separated by separator if provided
409
+ *
410
+ * @internal
260
411
  */
261
- function join(maybeArray: ?Array<string>, separator = ''): string {
262
- return maybeArray?.filter((x) => x).join(separator) ?? '';
412
+ function join(
413
+ maybeArray: Maybe<$ReadOnlyArray<string | PrintBuffer | void>>,
414
+ separator = '',
415
+ ): PrintBuffer {
416
+ if (maybeArray == null || maybeArray.length === 0) {
417
+ return EMPTY;
418
+ }
419
+ let result = EMPTY;
420
+ for (const item of maybeArray) {
421
+ if (item === undefined || item.length === 0) {
422
+ continue;
423
+ }
424
+ if (result.length === 0) {
425
+ result = typeof item === 'string' ? new PrintBuffer(item) : item;
426
+ } else {
427
+ if (separator !== '') {
428
+ result.append(separator);
429
+ }
430
+ result.append(item);
431
+ }
432
+ }
433
+ return result;
263
434
  }
264
435
 
265
- /**
266
- * Given array, print each item on its own line, wrapped in an
267
- * indented "{ }" block.
268
- */
269
- function block(array: ?Array<string>): string {
270
- return wrap('{\n', indent(join(array, '\n')), '\n}');
436
+ function joinedLength(
437
+ array: $ReadOnlyArray<PrintBuffer>,
438
+ separator: string,
439
+ ): number {
440
+ let length = 0;
441
+ for (const item of array) {
442
+ if (item.length !== 0) {
443
+ length += (length === 0 ? 0 : separator.length) + item.length;
444
+ }
445
+ }
446
+ return length;
271
447
  }
272
448
 
273
449
  /**
274
- * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.
450
+ * Given array, print each item on its own line, wrapped in an indented `{ }` block.
451
+ *
452
+ * @internal
275
453
  */
276
- function wrap(start: string, maybeString: ?string, end: string = ''): string {
277
- return maybeString != null && maybeString !== ''
278
- ? start + maybeString + end
279
- : '';
454
+ function block(array: Maybe<$ReadOnlyArray<PrintBuffer | void>>): PrintBuffer {
455
+ return wrap('{\n', join(array, '\n').indent(), '\n}');
280
456
  }
281
457
 
282
- function indent(str: string): string {
283
- return wrap(' ', str.replace(/\n/g, '\n '));
458
+ /**
459
+ * If maybeBuffer is not null or empty, then wrap with start and end, otherwise print an empty string.
460
+ *
461
+ * @internal
462
+ */
463
+ function wrap(
464
+ start: string,
465
+ maybeBuffer: Maybe<PrintBuffer>,
466
+ end = '',
467
+ ): PrintBuffer {
468
+ return maybeBuffer != null && maybeBuffer.length !== 0
469
+ ? start === ''
470
+ ? maybeBuffer.append(end)
471
+ : new PrintBuffer(start).append(maybeBuffer).append(end)
472
+ : EMPTY;
284
473
  }
285
474
 
286
- function isMultiline(str: string): boolean {
287
- return str.indexOf('\n') !== -1;
475
+ function hasMultilineItems(
476
+ maybeArray: Maybe<$ReadOnlyArray<PrintBuffer>>,
477
+ ): boolean {
478
+ return (
479
+ maybeArray != null && maybeArray.some((result) => result.newlines !== 0)
480
+ );
288
481
  }
289
482
 
290
- function hasMultilineItems(maybeArray: ?Array<string>): boolean {
291
- return maybeArray != null && maybeArray.some(isMultiline);
483
+ function wrappedLineAndArgs(
484
+ prefix: PrintBuffer,
485
+ args: $ReadOnlyArray<PrintBuffer> | void,
486
+ ): PrintBuffer {
487
+ if (args == null || args.length === 0) {
488
+ return prefix;
489
+ }
490
+ return join([
491
+ prefix,
492
+ prefix.length + joinedLength(args, ', ') + 2 > MAX_LINE_LENGTH
493
+ ? wrap('(\n', join(args, '\n').indent(), '\n)')
494
+ : wrap('(', join(args, ', '), ')'),
495
+ ]);
292
496
  }