vscode-json-languageservice 5.1.4 → 5.3.0

package/lib/esm/utils/sort.js

@@ -0,0 +1,355 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+// import { TextEdit} from 'vscode-languageserver-textdocument';
+import { createScanner } from 'jsonc-parser';
+import { TextDocument, TextEdit, Position, Range } from '../jsonLanguageTypes';
+import { format } from './format';
+import { PropertyTree, Container } from './propertyTree';
+export function sort(documentToSort, formattingOptions) {
+    const options = {
+        ...formattingOptions,
+        keepLines: false, // keepLines must be false so that the properties are on separate lines for the sorting
+    };
+    const formattedJsonString = TextDocument.applyEdits(documentToSort, format(documentToSort, options, undefined));
+    const formattedJsonDocument = TextDocument.create('test://test.json', 'json', 0, formattedJsonString);
+    const jsonPropertyTree = findJsoncPropertyTree(formattedJsonDocument);
+    const sortedJsonDocument = sortJsoncDocument(formattedJsonDocument, jsonPropertyTree);
+    const edits = format(sortedJsonDocument, options, undefined);
+    const sortedAndFormattedJsonDocument = TextDocument.applyEdits(sortedJsonDocument, edits);
+    return [TextEdit.replace(Range.create(Position.create(0, 0), documentToSort.positionAt(documentToSort.getText().length)), sortedAndFormattedJsonDocument)];
+}
+function findJsoncPropertyTree(formattedDocument) {
+    const formattedString = formattedDocument.getText();
+    const scanner = createScanner(formattedString, false);
+    // The tree that will be returned
+    let rootTree = new PropertyTree();
+    // The tree where the current properties can be added as children
+    let currentTree = rootTree;
+    // The tree representing the current property analyzed
+    let currentProperty = rootTree;
+    // The tree representing the previous property analyzed
+    let lastProperty = rootTree;
+    // The current scanned token
+    let token = undefined;
+    // Line number of the last token found
+    let lastTokenLine = 0;
+    // Total number of characters on the lines prior to current line 
+    let numberOfCharactersOnPreviousLines = 0;
+    // The last token scanned that is not trivial, nor a comment
+    let lastNonTriviaNonCommentToken = undefined;
+    // The second to last token scanned that is not trivial, nor a comment
+    let secondToLastNonTriviaNonCommentToken = undefined;
+    // Line number of last token that is not trivial, nor a comment
+    let lineOfLastNonTriviaNonCommentToken = -1;
+    // End index on its line of last token that is not trivial, nor a comment
+    let endIndexOfLastNonTriviaNonCommentToken = -1;
+    // Line number of the start of the range of current/next property
+    let beginningLineNumber = 0;
+    // Line number of the end of the range of current/next property
+    let endLineNumber = 0;
+    // Stack indicating whether we are inside of an object or an array
+    let currentContainerStack = [];
+    // Boolean indicating that the current property end line number needs to be updated. Used only when block comments are encountered.
+    let updateLastPropertyEndLineNumber = false;
+    // Boolean indicating that the beginning line number should be updated. Used only when block comments are encountered. 
+    let updateBeginningLineNumber = false;
+    while ((token = scanner.scan()) !== 17 /* SyntaxKind.EOF */) {
+        // In the case when a block comment has been encountered that starts on the same line as the comma ending a property, update the end line of that
+        // property so that it covers the block comment. For example, if we have: 
+        // 1. "key" : {}, /* some block
+        // 2. comment */
+        // Then, the end line of the property "key" should be line 2 not line 1
+        if (updateLastPropertyEndLineNumber === true
+            && token !== 14 /* SyntaxKind.LineBreakTrivia */
+            && token !== 15 /* SyntaxKind.Trivia */
+            && token !== 12 /* SyntaxKind.LineCommentTrivia */
+            && token !== 13 /* SyntaxKind.BlockCommentTrivia */
+            && currentProperty.endLineNumber === undefined) {
+            let endLineNumber = scanner.getTokenStartLine();
+            // Update the end line number in the case when the last property visited is a container (object or array)
+            if (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
+                || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) {
+                lastProperty.endLineNumber = endLineNumber - 1;
+            }
+            // Update the end line number in the case when the last property visited is a simple property 
+            else {
+                currentProperty.endLineNumber = endLineNumber - 1;
+            }
+            beginningLineNumber = endLineNumber;
+            updateLastPropertyEndLineNumber = false;
+        }
+        // When a block comment follows an open brace or an open bracket, that block comment should be associated to that brace or bracket, not the property below it. For example, for:
+        // 1. { /*
+        // 2. ... */
+        // 3. "key" : {}
+        // 4. }
+        // Instead of associating the block comment to the property on line 3, it is associate to the property on line 1
+        if (updateBeginningLineNumber === true
+            && token !== 14 /* SyntaxKind.LineBreakTrivia */
+            && token !== 15 /* SyntaxKind.Trivia */
+            && token !== 12 /* SyntaxKind.LineCommentTrivia */
+            && token !== 13 /* SyntaxKind.BlockCommentTrivia */) {
+            beginningLineNumber = scanner.getTokenStartLine();
+            updateBeginningLineNumber = false;
+        }
+        // Update the number of characters on all the previous lines each time the new token is on a different line to the previous token
+        if (scanner.getTokenStartLine() !== lastTokenLine) {
+            for (let i = lastTokenLine; i < scanner.getTokenStartLine(); i++) {
+                const lengthOfLine = formattedDocument.getText(Range.create(Position.create(i, 0), Position.create(i + 1, 0))).length;
+                numberOfCharactersOnPreviousLines = numberOfCharactersOnPreviousLines + lengthOfLine;
+            }
+            lastTokenLine = scanner.getTokenStartLine();
+        }
+        switch (token) {
+            // When a string is found, if it follows an open brace or a comma token and it is within an object, then it corresponds to a key name, not a simple string
+            case 10 /* SyntaxKind.StringLiteral */: {
+                if ((lastNonTriviaNonCommentToken === undefined
+                    || lastNonTriviaNonCommentToken === 1 /* SyntaxKind.OpenBraceToken */
+                    || (lastNonTriviaNonCommentToken === 5 /* SyntaxKind.CommaToken */
+                        && currentContainerStack[currentContainerStack.length - 1] === Container.Object))) {
+                    // In that case create the child property which starts at beginningLineNumber, add it to the current tree
+                    const childProperty = new PropertyTree(scanner.getTokenValue(), beginningLineNumber);
+                    lastProperty = currentProperty;
+                    currentProperty = currentTree.addChildProperty(childProperty);
+                }
+                break;
+            }
+            // When the token is an open bracket, then we enter into an array
+            case 3 /* SyntaxKind.OpenBracketToken */: {
+                // If the root tree beginning line number is not defined, then this open bracket is the first open bracket in the document
+                if (rootTree.beginningLineNumber === undefined) {
+                    rootTree.beginningLineNumber = scanner.getTokenStartLine();
+                }
+                // Suppose we are inside of an object, then the current array is associated to a key, and has already been created
+                // We have the following configuration: {"a": "val", "array": [...], "b": "val"}
+                // In that case navigate down to the child property
+                if (currentContainerStack[currentContainerStack.length - 1] === Container.Object) {
+                    currentTree = currentProperty;
+                }
+                // Suppose we are inside of an array, then since the current array is not associated to a key, it has not been created yet
+                // We have the following configuration: ["a", [...], "b"]
+                // In that case create the property and navigate down
+                else if (currentContainerStack[currentContainerStack.length - 1] === Container.Array) {
+                    const childProperty = new PropertyTree(scanner.getTokenValue(), beginningLineNumber);
+                    childProperty.noKeyName = true;
+                    lastProperty = currentProperty;
+                    currentProperty = currentTree.addChildProperty(childProperty);
+                }
+                currentContainerStack.push(Container.Array);
+                currentProperty.type = Container.Array;
+                beginningLineNumber = scanner.getTokenStartLine();
+                beginningLineNumber++;
+                break;
+            }
+            // When the token is an open brace, then we enter into an object
+            case 1 /* SyntaxKind.OpenBraceToken */: {
+                // If the root tree beginning line number is not defined, then this open brace is the first open brace in the document
+                if (rootTree.beginningLineNumber === undefined) {
+                    rootTree.beginningLineNumber = scanner.getTokenStartLine();
+                }
+                // 1. If we are inside of an objet, the current object is associated to a key and has already been created
+                // We have the following configuration: {"a": "val", "object": {...}, "b": "val"}
+                // 2. Otherwise the current object property is inside of an array, not associated to a key name and the property has not yet been created
+                // We have the following configuration: ["a", {...}, "b"]
+                else if (currentContainerStack[currentContainerStack.length - 1] === Container.Array) {
+                    const childProperty = new PropertyTree(scanner.getTokenValue(), beginningLineNumber);
+                    childProperty.noKeyName = true;
+                    lastProperty = currentProperty;
+                    currentProperty = currentTree.addChildProperty(childProperty);
+                }
+                currentProperty.type = Container.Object;
+                currentContainerStack.push(Container.Object);
+                currentTree = currentProperty;
+                beginningLineNumber = scanner.getTokenStartLine();
+                beginningLineNumber++;
+                break;
+            }
+            case 4 /* SyntaxKind.CloseBracketToken */: {
+                endLineNumber = scanner.getTokenStartLine();
+                currentContainerStack.pop();
+                // If the last non-trivial non-comment token is a closing brace or bracket, then the currentProperty end line number has not been set yet so set it
+                // The configuration considered is: [..., {}] or [..., []]
+                if (currentProperty.endLineNumber === undefined
+                    && (lastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
+                        || lastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)) {
+                    currentProperty.endLineNumber = endLineNumber - 1;
+                    currentProperty.lastProperty = true;
+                    currentProperty.lineWhereToAddComma = lineOfLastNonTriviaNonCommentToken;
+                    currentProperty.indexWhereToAddComa = endIndexOfLastNonTriviaNonCommentToken;
+                    lastProperty = currentProperty;
+                    currentProperty = currentProperty ? currentProperty.parent : undefined;
+                    currentTree = currentProperty;
+                }
+                rootTree.endLineNumber = endLineNumber;
+                beginningLineNumber = endLineNumber + 1;
+                break;
+            }
+            case 2 /* SyntaxKind.CloseBraceToken */: {
+                endLineNumber = scanner.getTokenStartLine();
+                currentContainerStack.pop();
+                // If we are not inside of an empty object and current property end line number has not yet been defined, define it
+                if (lastNonTriviaNonCommentToken !== 1 /* SyntaxKind.OpenBraceToken */
+                    && currentProperty.endLineNumber === undefined) {
+                    currentProperty.endLineNumber = endLineNumber - 1;
+                    // The current property is also the last property
+                    currentProperty.lastProperty = true;
+                    // The last property of an object is associated with the line and index of where to add the comma, in case after sorting, it is no longer the last property
+                    currentProperty.lineWhereToAddComma = lineOfLastNonTriviaNonCommentToken;
+                    currentProperty.indexWhereToAddComa = endIndexOfLastNonTriviaNonCommentToken;
+                    lastProperty = currentProperty;
+                    currentProperty = currentProperty ? currentProperty.parent : undefined;
+                    currentTree = currentProperty;
+                }
+                rootTree.endLineNumber = scanner.getTokenStartLine();
+                beginningLineNumber = endLineNumber + 1;
+                break;
+            }
+            case 5 /* SyntaxKind.CommaToken */: {
+                endLineNumber = scanner.getTokenStartLine();
+                // If the current container is an object or the current container is an array and the last non-trivia non-comment token is a closing brace or a closing bracket
+                // Then update the end line number of the current property
+                if (currentProperty.endLineNumber === undefined
+                    && (currentContainerStack[currentContainerStack.length - 1] === Container.Object
+                        || (currentContainerStack[currentContainerStack.length - 1] === Container.Array
+                            && (lastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
+                                || lastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)))) {
+                    currentProperty.endLineNumber = endLineNumber;
+                    // Store the line and the index of the comma in case it needs to be removed during the sorting
+                    currentProperty.commaIndex = scanner.getTokenOffset() - numberOfCharactersOnPreviousLines;
+                    currentProperty.commaLine = endLineNumber;
+                }
+                if (lastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
+                    || lastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) {
+                    lastProperty = currentProperty;
+                    currentProperty = currentProperty ? currentProperty.parent : undefined;
+                    currentTree = currentProperty;
+                }
+                beginningLineNumber = endLineNumber + 1;
+                break;
+            }
+            case 13 /* SyntaxKind.BlockCommentTrivia */: {
+                // If the last non trivia non-comment token is a comma and the block comment starts on the same line as the comma, then update the end line number of the current property. For example if:
+                // 1. {}, /* ...
+                // 2. ..*/
+                // The the property on line 1 shoud end on line 2, not line 1
+                // In the case we are in an array we update the end line number only if the second to last non-trivia non-comment token is a closing brace or bracket
+                if (lastNonTriviaNonCommentToken === 5 /* SyntaxKind.CommaToken */
+                    && lineOfLastNonTriviaNonCommentToken === scanner.getTokenStartLine()
+                    && (currentContainerStack[currentContainerStack.length - 1] === Container.Array
+                        && (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
+                            || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)
+                        || currentContainerStack[currentContainerStack.length - 1] === Container.Object)) {
+                    if (currentContainerStack[currentContainerStack.length - 1] === Container.Array && (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */ || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) || currentContainerStack[currentContainerStack.length - 1] === Container.Object) {
+                        currentProperty.endLineNumber = undefined;
+                        updateLastPropertyEndLineNumber = true;
+                    }
+                }
+                // When the block comment follows an open brace or an open token, we have the following scenario:
+                // { /**
+                // ../
+                // }
+                // The block comment should be assigned to the open brace not the first property below it
+                if ((lastNonTriviaNonCommentToken === 1 /* SyntaxKind.OpenBraceToken */
+                    || lastNonTriviaNonCommentToken === 3 /* SyntaxKind.OpenBracketToken */)
+                    && lineOfLastNonTriviaNonCommentToken === scanner.getTokenStartLine()) {
+                    updateBeginningLineNumber = true;
+                }
+                break;
+            }
+        }
+        // Update the last and second to last non-trivia non-comment tokens
+        if (token !== 14 /* SyntaxKind.LineBreakTrivia */
+            && token !== 13 /* SyntaxKind.BlockCommentTrivia */
+            && token !== 12 /* SyntaxKind.LineCommentTrivia */
+            && token !== 15 /* SyntaxKind.Trivia */) {
+            secondToLastNonTriviaNonCommentToken = lastNonTriviaNonCommentToken;
+            lastNonTriviaNonCommentToken = token;
+            lineOfLastNonTriviaNonCommentToken = scanner.getTokenStartLine();
+            endIndexOfLastNonTriviaNonCommentToken = scanner.getTokenOffset() + scanner.getTokenLength() - numberOfCharactersOnPreviousLines;
+        }
+    }
+    return rootTree;
+}
+function sortJsoncDocument(jsonDocument, propertyTree) {
+    if (propertyTree.childrenProperties.length === 0) {
+        return jsonDocument;
+    }
+    const sortedJsonDocument = TextDocument.create('test://test.json', 'json', 0, jsonDocument.getText());
+    const queueToSort = [];
+    updateSortingQueue(queueToSort, propertyTree, propertyTree.beginningLineNumber);
+    while (queueToSort.length > 0) {
+        const dataToSort = queueToSort.shift();
+        const propertyTreeArray = dataToSort.propertyTreeArray;
+        let beginningLineNumber = dataToSort.beginningLineNumber;
+        for (let i = 0; i < propertyTreeArray.length; i++) {
+            const propertyTree = propertyTreeArray[i];
+            const range = Range.create(Position.create(propertyTree.beginningLineNumber, 0), Position.create(propertyTree.endLineNumber + 1, 0));
+            const jsonContentToReplace = jsonDocument.getText(range);
+            const jsonDocumentToReplace = TextDocument.create('test://test.json', 'json', 0, jsonContentToReplace);
+            if (propertyTree.lastProperty === true && i !== propertyTreeArray.length - 1) {
+                const lineWhereToAddComma = propertyTree.lineWhereToAddComma - propertyTree.beginningLineNumber;
+                const indexWhereToAddComma = propertyTree.indexWhereToAddComa;
+                const edit = {
+                    range: Range.create(Position.create(lineWhereToAddComma, indexWhereToAddComma), Position.create(lineWhereToAddComma, indexWhereToAddComma)),
+                    text: ','
+                };
+                TextDocument.update(jsonDocumentToReplace, [edit], 1);
+            }
+            else if (propertyTree.lastProperty === false && i === propertyTreeArray.length - 1) {
+                const commaIndex = propertyTree.commaIndex;
+                const commaLine = propertyTree.commaLine;
+                const lineWhereToRemoveComma = commaLine - propertyTree.beginningLineNumber;
+                const edit = {
+                    range: Range.create(Position.create(lineWhereToRemoveComma, commaIndex), Position.create(lineWhereToRemoveComma, commaIndex + 1)),
+                    text: ''
+                };
+                TextDocument.update(jsonDocumentToReplace, [edit], 1);
+            }
+            const length = propertyTree.endLineNumber - propertyTree.beginningLineNumber + 1;
+            const edit = {
+                range: Range.create(Position.create(beginningLineNumber, 0), Position.create(beginningLineNumber + length, 0)),
+                text: jsonDocumentToReplace.getText()
+            };
+            TextDocument.update(sortedJsonDocument, [edit], 1);
+            updateSortingQueue(queueToSort, propertyTree, beginningLineNumber);
+            beginningLineNumber = beginningLineNumber + length;
+        }
+    }
+    return sortedJsonDocument;
+}
+function updateSortingQueue(queue, propertyTree, beginningLineNumber) {
+    if (propertyTree.childrenProperties.length === 0) {
+        return;
+    }
+    if (propertyTree.type === Container.Object) {
+        let minimumBeginningLineNumber = Infinity;
+        for (const childProperty of propertyTree.childrenProperties) {
+            if (childProperty.beginningLineNumber < minimumBeginningLineNumber) {
+                minimumBeginningLineNumber = childProperty.beginningLineNumber;
+            }
+        }
+        const diff = minimumBeginningLineNumber - propertyTree.beginningLineNumber;
+        beginningLineNumber = beginningLineNumber + diff;
+        queue.push(new SortingRange(beginningLineNumber, propertyTree.childrenProperties));
+    }
+    else if (propertyTree.type === Container.Array) {
+        for (const subObject of propertyTree.childrenProperties) {
+            let minimumBeginningLineNumber = Infinity;
+            for (const childProperty of subObject.childrenProperties) {
+                if (childProperty.beginningLineNumber < minimumBeginningLineNumber) {
+                    minimumBeginningLineNumber = childProperty.beginningLineNumber;
+                }
+            }
+            const diff = minimumBeginningLineNumber - subObject.beginningLineNumber;
+            queue.push(new SortingRange(beginningLineNumber + subObject.beginningLineNumber - propertyTree.beginningLineNumber + diff, subObject.childrenProperties));
+        }
+    }
+}
+class SortingRange {
+    constructor(beginningLineNumber, propertyTreeArray) {
+        this.beginningLineNumber = beginningLineNumber;
+        this.propertyTreeArray = propertyTreeArray;
+    }
+}

package/lib/esm/utils/strings.js

@@ -32,7 +32,7 @@ export function convertSimple2RegExpPattern(pattern) {
     return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
 }
 export function repeat(value, count) {
-    var s = '';
+    let s = '';
     while (count > 0) {
         if ((count & 1) === 1) {
             s += value;

package/lib/umd/jsonLanguageService.d.ts

@@ -1,4 +1,4 @@
-import { Thenable, ASTNode, Color, ColorInformation, ColorPresentation, LanguageServiceParams, LanguageSettings, DocumentLanguageSettings, FoldingRange, JSONSchema, SelectionRange, FoldingRangesContext, DocumentSymbolsContext, ColorInformationContext as DocumentColorsContext, TextDocument, Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic, TextEdit, FormattingOptions, DocumentSymbol, DefinitionLink, MatchingSchema, JSONLanguageStatus } from './jsonLanguageTypes';
+import { Thenable, ASTNode, Color, ColorInformation, ColorPresentation, LanguageServiceParams, LanguageSettings, DocumentLanguageSettings, FoldingRange, JSONSchema, SelectionRange, FoldingRangesContext, DocumentSymbolsContext, ColorInformationContext as DocumentColorsContext, TextDocument, Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic, TextEdit, FormattingOptions, DocumentSymbol, DefinitionLink, MatchingSchema, JSONLanguageStatus, SortOptions } from './jsonLanguageTypes';
 import { DocumentLink } from 'vscode-languageserver-types';
 export type JSONDocument = {
     root: ASTNode | undefined;
@@ -20,10 +20,11 @@ export interface LanguageService {
     findDocumentColors(document: TextDocument, doc: JSONDocument, context?: DocumentColorsContext): Thenable<ColorInformation[]>;
     getColorPresentations(document: TextDocument, doc: JSONDocument, color: Color, range: Range): ColorPresentation[];
     doHover(document: TextDocument, position: Position, doc: JSONDocument): Thenable<Hover | null>;
-    format(document: TextDocument, range: Range, options: FormattingOptions): TextEdit[];
     getFoldingRanges(document: TextDocument, context?: FoldingRangesContext): FoldingRange[];
     getSelectionRanges(document: TextDocument, positions: Position[], doc: JSONDocument): SelectionRange[];
     findDefinition(document: TextDocument, position: Position, doc: JSONDocument): Thenable<DefinitionLink[]>;
     findLinks(document: TextDocument, doc: JSONDocument): Thenable<DocumentLink[]>;
+    format(document: TextDocument, range: Range, options: FormattingOptions): TextEdit[];
+    sort(document: TextDocument, options: SortOptions): TextEdit[];
 }
 export declare function getLanguageService(params: LanguageServiceParams): LanguageService;

package/lib/umd/jsonLanguageService.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./services/jsonCompletion", "./services/jsonHover", "./services/jsonValidation", "./services/jsonDocumentSymbols", "./parser/jsonParser", "./services/configuration", "./services/jsonSchemaService", "./services/jsonFolding", "./services/jsonSelectionRanges", "jsonc-parser", "./jsonLanguageTypes", "./services/jsonLinks", "./jsonLanguageTypes"], factory);
+        define(["require", "exports", "./services/jsonCompletion", "./services/jsonHover", "./services/jsonValidation", "./services/jsonDocumentSymbols", "./parser/jsonParser", "./services/configuration", "./services/jsonSchemaService", "./services/jsonFolding", "./services/jsonSelectionRanges", "./utils/sort", "./utils/format", "./services/jsonLinks", "./jsonLanguageTypes"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -37,8 +37,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     const jsonSchemaService_1 = require("./services/jsonSchemaService");
     const jsonFolding_1 = require("./services/jsonFolding");
     const jsonSelectionRanges_1 = require("./services/jsonSelectionRanges");
-    const jsonc_parser_1 = require("jsonc-parser");
-    const jsonLanguageTypes_1 = require("./jsonLanguageTypes");
+    const sort_1 = require("./utils/sort");
+    const format_1 = require("./utils/format");
     const jsonLinks_1 = require("./services/jsonLinks");
     __exportStar(require("./jsonLanguageTypes"), exports);
     function getLanguageService(params) {
@@ -52,11 +52,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
         return {
             configure: (settings) => {
                 jsonSchemaService.clearExternalSchemas();
-                if (settings.schemas) {
-                    settings.schemas.forEach(settings => {
-                        jsonSchemaService.registerExternalSchema(settings.uri, settings.fileMatch, settings.schema);
-                    });
-                }
+                settings.schemas?.forEach(jsonSchemaService.registerExternalSchema.bind(jsonSchemaService));
                 jsonValidation.configure(settings);
             },
             resetSchema: (uri) => jsonSchemaService.onResourceChange(uri),
@@ -76,18 +72,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
             getSelectionRanges: jsonSelectionRanges_1.getSelectionRanges,
             findDefinition: () => Promise.resolve([]),
             findLinks: jsonLinks_1.findLinks,
-            format: (d, r, o) => {
-                let range = undefined;
-                if (r) {
-                    const offset = d.offsetAt(r.start);
-                    const length = d.offsetAt(r.end) - offset;
-                    range = { offset, length };
-                }
-                const options = { tabSize: o ? o.tabSize : 4, insertSpaces: o?.insertSpaces === true, insertFinalNewline: o?.insertFinalNewline === true, eol: '\n', keepLines: o?.keepLines === true };
-                return (0, jsonc_parser_1.format)(d.getText(), range, options).map(e => {
-                    return jsonLanguageTypes_1.TextEdit.replace(jsonLanguageTypes_1.Range.create(d.positionAt(e.offset), d.positionAt(e.offset + e.length)), e.content);
-                });
-            }
+            format: (document, range, options) => (0, format_1.format)(document, options, range),
+            sort: (document, options) => (0, sort_1.sort)(document, options)
         };
     }
     exports.getLanguageService = getLanguageService;

package/lib/umd/jsonLanguageTypes.d.ts

@@ -1,8 +1,8 @@
 import { JSONWorkerContribution, JSONPath, Segment, CompletionsCollector } from './jsonContributions';
 import { JSONSchema } from './jsonSchema';
 import { Range, Position, DocumentUri, MarkupContent, MarkupKind, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, Diagnostic, DiagnosticSeverity, CompletionItem, CompletionItemKind, CompletionList, CompletionItemTag, InsertTextFormat, SymbolInformation, SymbolKind, DocumentSymbol, Location, Hover, MarkedString, FormattingOptions as LSPFormattingOptions, DefinitionLink, CodeActionContext, Command, CodeAction, DocumentHighlight, DocumentLink, WorkspaceEdit, TextEdit, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier, DocumentHighlightKind } from 'vscode-languageserver-types';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-export { TextDocument, Range, Position, DocumentUri, MarkupContent, MarkupKind, JSONSchema, JSONWorkerContribution, JSONPath, Segment, CompletionsCollector, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, Diagnostic, DiagnosticSeverity, CompletionItem, CompletionItemKind, CompletionList, CompletionItemTag, InsertTextFormat, DefinitionLink, SymbolInformation, SymbolKind, DocumentSymbol, Location, Hover, MarkedString, CodeActionContext, Command, CodeAction, DocumentHighlight, DocumentLink, WorkspaceEdit, TextEdit, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier, DocumentHighlightKind };
+import { TextDocument, TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
+export { TextDocument, TextDocumentContentChangeEvent, Range, Position, DocumentUri, MarkupContent, MarkupKind, JSONSchema, JSONWorkerContribution, JSONPath, Segment, CompletionsCollector, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, Diagnostic, DiagnosticSeverity, CompletionItem, CompletionItemKind, CompletionList, CompletionItemTag, InsertTextFormat, DefinitionLink, SymbolInformation, SymbolKind, DocumentSymbol, Location, Hover, MarkedString, CodeActionContext, Command, CodeAction, DocumentHighlight, DocumentLink, WorkspaceEdit, TextEdit, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier, DocumentHighlightKind };
 /**
  * Error codes used by diagnostics
  */
@@ -141,6 +141,11 @@ export interface SchemaConfiguration {
      * If no schema is provided, the schema will be fetched with the schema request service (if available).
      */
     schema?: JSONSchema;
+    /**
+     * A parent folder for folder specifc associations. An association that has a folder URI set is only used
+     * if the document that is validated has the folderUri as parent
+     */
+    folderUri?: string;
 }
 export interface WorkspaceContextService {
     resolveRelativePath(relativePath: string, resource: string): string;
@@ -290,3 +295,6 @@ export interface FormattingOptions extends LSPFormattingOptions {
     insertFinalNewline?: boolean;
     keepLines?: boolean;
 }
+export interface SortOptions extends LSPFormattingOptions {
+    insertFinalNewline?: boolean;
+}

package/lib/umd/services/jsonCompletion.js

@@ -699,7 +699,7 @@
             return text.replace(/[\\\$\}]/g, '\\$&'); // escape $, \ and } 
         }
         getInsertTextForValue(value, separatorAfter) {
-            var text = JSON.stringify(value, null, '\t');
+            const text = JSON.stringify(value, null, '\t');
             if (text === '{}') {
                 return '{$1}' + separatorAfter;
             }
@@ -817,7 +817,7 @@
                     nValueProposals += propertySchema.examples.length;
                 }
                 if (nValueProposals === 0) {
-                    var type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
+                    let type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
                     if (!type) {
                         if (propertySchema.properties) {
                             type = 'object';
@@ -857,8 +857,8 @@
             return resultText + value + separatorAfter;
         }
         getCurrentWord(document, offset) {
-            var i = offset - 1;
-            var text = document.getText();
+            let i = offset - 1;
+            const text = document.getText();
             while (i >= 0 && ' \t\n\r\v":{[,]}'.indexOf(text.charAt(i)) === -1) {
                 i--;
             }

package/lib/umd/services/jsonDocumentSymbols.js

@@ -8,7 +8,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../parser/jsonParser", "../utils/strings", "../utils/colors", "../jsonLanguageTypes"], factory);
+        define(["require", "exports", "../parser/jsonParser", "../utils/strings", "../utils/colors", "@vscode/l10n", "../jsonLanguageTypes"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -17,6 +17,7 @@
     const Parser = require("../parser/jsonParser");
     const Strings = require("../utils/strings");
     const colors_1 = require("../utils/colors");
+    const l10n = require("@vscode/l10n");
     const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
     class JSONDocumentSymbols {
         constructor(schemaService) {
@@ -38,7 +39,7 @@
                             for (const property of item.properties) {
                                 if (property.keyNode.value === 'key' && property.valueNode) {
                                     const location = jsonLanguageTypes_1.Location.create(document.uri, getRange(document, item));
-                                    result.push({ name: Parser.getNodeValue(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, location: location });
+                                    result.push({ name: getName(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, location: location });
                                     limit--;
                                     if (limit <= 0) {
                                         if (context && context.onResultLimitExceeded) {
@@ -112,7 +113,7 @@
                                 if (property.keyNode.value === 'key' && property.valueNode) {
                                     const range = getRange(document, item);
                                     const selectionRange = getRange(document, property.keyNode);
-                                    result.push({ name: Parser.getNodeValue(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, range, selectionRange });
+                                    result.push({ name: getName(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, range, selectionRange });
                                     limit--;
                                     if (limit <= 0) {
                                         if (context && context.onResultLimitExceeded) {
@@ -278,4 +279,7 @@
     function getRange(document, node) {
         return jsonLanguageTypes_1.Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
     }
+    function getName(node) {
+        return Parser.getNodeValue(node) || l10n.t('<empty>');
+    }
 });

package/lib/umd/services/jsonHover.js

@@ -40,7 +40,7 @@
                 }
             }
             const hoverRange = jsonLanguageTypes_1.Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
-            var createHover = (contents) => {
+            const createHover = (contents) => {
                 const result = {
                     contents: contents,
                     range: hoverRange

package/lib/umd/services/jsonSchemaService.js

@@ -24,7 +24,9 @@
     const BANG = '!';
     const PATH_SEP = '/';
     class FilePatternAssociation {
-        constructor(pattern, uris) {
+        constructor(pattern, folderUri, uris) {
+            this.folderUri = folderUri;
+            this.uris = uris;
             this.globWrappers = [];
             try {
                 for (let patternString of pattern) {
@@ -43,7 +45,9 @@
                     }
                 }
                 ;
-                this.uris = uris;
+                if (folderUri && !folderUri.endsWith('/')) {
+                    this.folderUri = folderUri + '/';
+                }
             }
             catch (e) {
                 this.globWrappers.length = 0;
@@ -51,6 +55,9 @@
             }
         }
         matchesPattern(fileName) {
+            if (this.folderUri && !fileName.startsWith(this.folderUri)) {
+                return false;
+            }
             let match = false;
             for (const { regexp, include } of this.globWrappers) {
                 if (regexp.test(fileName)) {
@@ -213,7 +220,7 @@
                 const schemaAssociations = schemaContributions.schemaAssociations;
                 for (let schemaAssociation of schemaAssociations) {
                     const uris = schemaAssociation.uris.map(normalizeId);
-                    const association = this.addFilePatternAssociation(schemaAssociation.pattern, uris);
+                    const association = this.addFilePatternAssociation(schemaAssociation.pattern, schemaAssociation.folderUri, uris);
                     this.contributionAssociations.push(association);
                 }
             }
@@ -226,19 +233,19 @@
         getOrAddSchemaHandle(id, unresolvedSchemaContent) {
             return this.schemasById[id] || this.addSchemaHandle(id, unresolvedSchemaContent);
         }
-        addFilePatternAssociation(pattern, uris) {
-            const fpa = new FilePatternAssociation(pattern, uris);
+        addFilePatternAssociation(pattern, folderUri, uris) {
+            const fpa = new FilePatternAssociation(pattern, folderUri, uris);
             this.filePatternAssociations.push(fpa);
             return fpa;
         }
-        registerExternalSchema(uri, filePatterns, unresolvedSchemaContent) {
-            const id = normalizeId(uri);
+        registerExternalSchema(config) {
+            const id = normalizeId(config.uri);
             this.registeredSchemasIds[id] = true;
             this.cachedSchemaForResource = undefined;
-            if (filePatterns) {
-                this.addFilePatternAssociation(filePatterns, [id]);
+            if (config.fileMatch && config.fileMatch.length) {
+                this.addFilePatternAssociation(config.fileMatch, config.folderUri, [id]);
             }
-            return unresolvedSchemaContent ? this.addSchemaHandle(id, unresolvedSchemaContent) : this.getOrAddSchemaHandle(id);
+            return config.schema ? this.addSchemaHandle(id, config.schema) : this.getOrAddSchemaHandle(id);
         }
         clearExternalSchemas() {
             this.schemasById = {};

package/lib/umd/services/jsonValidation.js

@@ -101,8 +101,8 @@
                 return diagnostics;
             };
             if (schema) {
-                const id = schema.id || ('schemaservice://untitled/' + idCounter++);
-                const handle = this.jsonSchemaService.registerExternalSchema(id, [], schema);
+                const uri = schema.id || ('schemaservice://untitled/' + idCounter++);
+                const handle = this.jsonSchemaService.registerExternalSchema({ uri, schema });
                 return handle.getResolvedSchema().then(resolvedSchema => {
                     return getDiagnostics(resolvedSchema);
                 });