src/vs/base/common/jsonFormatter.ts
261 LOC · 253 covered · 8 uncovered · 71 ranges · 2367 concepts · 32 introducers · 1185 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
jsonFormatter.ts ×6
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { createScanner, ScanError, SyntaxKind } from './json.js';
7
>
8
>
export interface FormattingOptions {
9
>
/**
10
>
* If indentation is based on spaces (`insertSpaces` = true), then what is the number of spaces that make an indent?
11
>
*/
12
>
tabSize?: number;
13
>
/**
14
>
* Is indentation based on spaces?
15
>
*/
16
>
insertSpaces?: boolean;
17
>
/**
18
>
* The default 'end of line' character. If not set, '\n' is used as default.
19
>
*/
20
>
eol?: string;
21
>
}
22
>
23
>
/**
24
>
* Represents a text modification
25
>
*/
26
>
export interface Edit {
27
>
/**
28
>
* The start offset of the modification.
29
>
*/
30
>
offset: number;
31
>
/**
32
>
* The length of the modification. Must not be negative. Empty length represents an *insert*.
33
>
*/
34
>
length: number;
35
>
/**
36
>
* The new content. Empty content represents a *remove*.
37
>
*/
38
>
content: string;
39
>
}
40
>
41
>
/**
42
>
* A text range in the document
43
>
*/
44
>
export interface Range {
45
>
/**
46
>
* The start offset of the range.
47
>
*/
48
>
offset: number;
49
>
/**
50
>
* The length of the range. Must not be negative.
51
>
*/
52
>
length: number;
53
>
}
54
>
55
>
56
>
export function format(documentText: string, range: Range | undefined, options: FormattingOptions): Edit[] {
58
>
let formatText: string;
59
>
let formatTextStart: number;
60
>
let rangeStart: number;
61
>
let rangeEnd: number;
62
>
if (range) {
64
>
rangeEnd = rangeStart + range.length;
65
>
66
>
formatTextStart = rangeStart;
67
>
while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
69
>
}
71
>
while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
73
>
}
75
>
initialIndentLevel = computeIndentLevel(formatText, options);
78
>
initialIndentLevel = 0;
79
>
formatTextStart = 0;
80
>
rangeStart = 0;
81
>
rangeEnd = documentText.length;
82
>
}
84
>
85
>
let lineBreak = false;
86
>
let indentLevel = 0;
87
>
let indentValue: string;
88
>
if (options.insertSpaces) {
92
>
}
94
>
const scanner = createScanner(formatText, false);
95
>
let hasError = false;
96
>
97
>
function newLineAndIndent(): string {
99
>
}
101
>
let token = scanner.scan();
102
>
lineBreak = false;
103
>
while (token === SyntaxKind.Trivia || token === SyntaxKind.LineBreakTrivia) {
105
>
token = scanner.scan();
106
>
}
107
>
hasError = token === SyntaxKind.Unknown || scanner.getTokenError() !== ScanError.None;
jsonFormatter.ts ×23
108
>
return token;
109
>
}
110
>
const editOperations: Edit[] = [];
111
>
function addEdit(text: string, startOffset: number, endOffset: number) {
112
>
if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
113
>
editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
jsonFormatter.ts ×1
114
>
}
116
>
117
>
let firstToken = scanNext();
118
>
119
>
if (firstToken !== SyntaxKind.EOF) {
120
>
const firstTokenStart = scanner.getTokenOffset() + formatTextStart;
121
>
const initialIndent = repeat(indentValue, initialIndentLevel);
122
>
addEdit(initialIndent, formatTextStart, firstTokenStart);
123
>
}
124
>
125
>
while (firstToken !== SyntaxKind.EOF) {
126
>
let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
127
>
let secondToken = scanNext();
128
>
129
>
let replaceContent = '';
130
>
while (!lineBreak && (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia)) {
131
>
// comments on the same line: keep them on the same line, but ignore them otherwise
jsonFormatter.ts ×1
132
>
const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
133
>
addEdit(' ', firstTokenEnd, commentTokenStart);
134
>
firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
135
>
replaceContent = secondToken === SyntaxKind.LineCommentTrivia ? newLineAndIndent() : '';
136
>
secondToken = scanNext();
137
>
}
139
>
if (secondToken === SyntaxKind.CloseBraceToken) {
142
>
replaceContent = newLineAndIndent();
143
>
}
147
>
replaceContent = newLineAndIndent();
148
>
}
150
>
switch (firstToken) {
151
>
case SyntaxKind.OpenBracketToken:
152
>
case SyntaxKind.OpenBraceToken:
154
>
replaceContent = newLineAndIndent();
155
>
break;
157
>
case SyntaxKind.LineCommentTrivia:
159
>
break;
164
>
// symbol following comment on the same line: keep on same line, separate with ' '
jsonFormatter.ts ×1
165
>
replaceContent = ' ';
166
>
}
170
>
break;
174
>
break;
175
>
}
177
>
case SyntaxKind.NullKeyword:
178
>
case SyntaxKind.TrueKeyword:
179
>
case SyntaxKind.FalseKeyword:
180
>
case SyntaxKind.NumericLiteral:
181
>
case SyntaxKind.CloseBraceToken:
182
>
case SyntaxKind.CloseBracketToken:
183
>
if (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia) {
jsonFormatter.ts ×3
185
>
} else if (secondToken !== SyntaxKind.CommaToken && secondToken !== SyntaxKind.EOF) {
jsonFormatter.ts ×3
187
>
}
190
hasError = true;
191
break;
193
>
if (lineBreak && (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia)) {
195
>
}
197
>
}
198
>
const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
199
>
addEdit(replaceContent, firstTokenEnd, secondTokenStart);
200
>
firstToken = secondToken;
201
>
}
202
>
return editOperations;
203
>
}
205
>
/**
206
>
* Creates a formatted string out of the object passed as argument, using the given formatting options
207
>
* @param any The object to stringify and format
208
>
* @param options The formatting options to use
209
>
*/
210
>
export function toFormattedString(obj: unknown, options: FormattingOptions) {
211
>
const content = JSON.stringify(obj, undefined, options.insertSpaces ? options.tabSize || 4 : '\t');
jsonFormatter.ts ×1
212
>
if (options.eol !== undefined) {
213
>
return content.replace(/\r\n|\r|\n/g, options.eol);
214
>
}
215
return content;
216
}
219
>
let result = '';
220
>
for (let i = 0; i < count; i++) {
221
>
result += s;
222
>
}
223
>
return result;
224
>
}
226
>
function computeIndentLevel(content: string, options: FormattingOptions): number {
jsonFormatter.ts ×8
227
>
let i = 0;
228
>
let nChars = 0;
229
>
const tabSize = options.tabSize || 4;
230
>
while (i < content.length) {
231
>
const ch = content.charAt(i);
232
>
if (ch === ' ') {
237
>
break;
238
>
}
240
>
}
242
>
}
244
>
export function getEOL(options: FormattingOptions, text: string): string {
246
>
const ch = text.charAt(i);
247
>
if (ch === '\r') {
248
if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
249
return '\r\n';
250
}
251
return '\r';
254
>
}
256
>
return (options && options.eol) || '\n';
257
>
}
259
>
export function isEOL(text: string, offset: number) {
261
>
}