vscode-json-languageservice 5.1.4 → 5.3.0

package/CHANGELOG.md

@@ -1,4 +1,13 @@
-5.2.0 / 2022-08/19
+5.3.0 / 2023-02-15
+================
+ * new API `LanguageService.sort` for sorting all properties in a JSON document
+ * new API `SortOptions`
+
+5.2.0 / 2023-02-02
+================
+ * Added `SchemaConfiguration.folderUri` for folder-specific schema associations
+
+5.1.1 / 2022-08/19
 ================
 * new type `SchemaDraft`, representing the offical JSON schema draft versions
 * new property `DocumentLanguageSettings.schemaDraft` to specify the schema version to use, if the schema does not contain a `$schema` property

package/lib/esm/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/esm/jsonLanguageService.js

@@ -11,8 +11,8 @@ import { schemaContributions } from './services/configuration';
 import { JSONSchemaService } from './services/jsonSchemaService';
 import { getFoldingRanges } from './services/jsonFolding';
 import { getSelectionRanges } from './services/jsonSelectionRanges';
-import { format as formatJSON } from 'jsonc-parser';
-import { Range, TextEdit } from './jsonLanguageTypes';
+import { sort } from './utils/sort';
+import { format } from './utils/format';
 import { findLinks } from './services/jsonLinks';
 export * from './jsonLanguageTypes';
 export function getLanguageService(params) {
@@ -26,11 +26,7 @@ export function getLanguageService(params) {
     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),
@@ -50,17 +46,7 @@ export function getLanguageService(params) {
         getSelectionRanges,
         findDefinition: () => Promise.resolve([]),
         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 formatJSON(d.getText(), range, options).map(e => {
-                return TextEdit.replace(Range.create(d.positionAt(e.offset), d.positionAt(e.offset + e.length)), e.content);
-            });
-        }
+        format: (document, range, options) => format(document, options, range),
+        sort: (document, options) => sort(document, options)
     };
 }

package/lib/esm/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/esm/services/jsonCompletion.js

@@ -687,7 +687,7 @@ export class JSONCompletion {
         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;
         }
@@ -805,7 +805,7 @@ export class JSONCompletion {
                 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';
@@ -845,8 +845,8 @@ export class JSONCompletion {
         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/esm/services/jsonDocumentSymbols.js

@@ -5,6 +5,7 @@
 import * as Parser from '../parser/jsonParser';
 import * as Strings from '../utils/strings';
 import { colorFromHex } from '../utils/colors';
+import * as l10n from '@vscode/l10n';
 import { Range, TextEdit, SymbolKind, Location } from "../jsonLanguageTypes";
 export class JSONDocumentSymbols {
     constructor(schemaService) {
@@ -26,7 +27,7 @@ export class JSONDocumentSymbols {
                         for (const property of item.properties) {
                             if (property.keyNode.value === 'key' && property.valueNode) {
                                 const location = Location.create(document.uri, getRange(document, item));
-                                result.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, location: location });
+                                result.push({ name: getName(property.valueNode), kind: SymbolKind.Function, location: location });
                                 limit--;
                                 if (limit <= 0) {
                                     if (context && context.onResultLimitExceeded) {
@@ -100,7 +101,7 @@ export class JSONDocumentSymbols {
                             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: SymbolKind.Function, range, selectionRange });
+                                result.push({ name: getName(property.valueNode), kind: SymbolKind.Function, range, selectionRange });
                                 limit--;
                                 if (limit <= 0) {
                                     if (context && context.onResultLimitExceeded) {
@@ -265,3 +266,6 @@ export class JSONDocumentSymbols {
 function getRange(document, node) {
     return Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
 }
+function getName(node) {
+    return Parser.getNodeValue(node) || l10n.t('<empty>');
+}

package/lib/esm/services/jsonHover.js

@@ -28,7 +28,7 @@ export class JSONHover {
             }
         }
         const hoverRange = 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/esm/services/jsonSchemaService.js

@@ -12,7 +12,9 @@ import { isObject, isString } from '../utils/objects';
 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) {
@@ -31,7 +33,9 @@ class FilePatternAssociation {
                 }
             }
             ;
-            this.uris = uris;
+            if (folderUri && !folderUri.endsWith('/')) {
+                this.folderUri = folderUri + '/';
+            }
         }
         catch (e) {
             this.globWrappers.length = 0;
@@ -39,6 +43,9 @@ class FilePatternAssociation {
         }
     }
     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)) {
@@ -199,7 +206,7 @@ export class JSONSchemaService {
             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);
             }
         }
@@ -212,19 +219,19 @@ export class JSONSchemaService {
     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/esm/services/jsonValidation.js

@@ -89,8 +89,8 @@ export class JSONValidation {
             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);
             });

package/lib/esm/utils/format.js

@@ -0,0 +1,20 @@
+import { format as formatJSON } from 'jsonc-parser';
+import { Range, TextEdit } from '../jsonLanguageTypes';
+export function format(documentToFormat, formattingOptions, formattingRange) {
+    let range = undefined;
+    if (formattingRange) {
+        const offset = documentToFormat.offsetAt(formattingRange.start);
+        const length = documentToFormat.offsetAt(formattingRange.end) - offset;
+        range = { offset, length };
+    }
+    const options = {
+        tabSize: formattingOptions ? formattingOptions.tabSize : 4,
+        insertSpaces: formattingOptions?.insertSpaces === true,
+        insertFinalNewline: formattingOptions?.insertFinalNewline === true,
+        eol: '\n',
+        keepLines: formattingOptions?.keepLines === true
+    };
+    return formatJSON(documentToFormat.getText(), range, options).map(edit => {
+        return TextEdit.replace(Range.create(documentToFormat.positionAt(edit.offset), documentToFormat.positionAt(edit.offset + edit.length)), edit.content);
+    });
+}

package/lib/esm/utils/objects.js

@@ -18,7 +18,7 @@ export function equals(one, other) {
     if ((Array.isArray(one)) !== (Array.isArray(other))) {
         return false;
     }
-    var i, key;
+    let i, key;
     if (Array.isArray(one)) {
         if (one.length !== other.length) {
             return false;
@@ -30,12 +30,12 @@ export function equals(one, other) {
         }
     }
     else {
-        var oneKeys = [];
+        const oneKeys = [];
         for (key in one) {
             oneKeys.push(key);
         }
         oneKeys.sort();
-        var otherKeys = [];
+        const otherKeys = [];
         for (key in other) {
             otherKeys.push(key);
         }

package/lib/esm/utils/propertyTree.js

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+export var Container;
+(function (Container) {
+    Container[Container["Object"] = 0] = "Object";
+    Container[Container["Array"] = 1] = "Array";
+})(Container || (Container = {}));
+export class PropertyTree {
+    constructor(propertyName, beginningLineNumber) {
+        this.propertyName = propertyName ?? '';
+        this.beginningLineNumber = beginningLineNumber;
+        this.childrenProperties = [];
+        this.lastProperty = false;
+        this.noKeyName = false;
+    }
+    addChildProperty(childProperty) {
+        childProperty.parent = this;
+        if (this.childrenProperties.length > 0) {
+            let insertionIndex = 0;
+            if (childProperty.noKeyName) {
+                insertionIndex = this.childrenProperties.length;
+            }
+            else {
+                insertionIndex = binarySearchOnPropertyArray(this.childrenProperties, childProperty, compareProperties);
+            }
+            if (insertionIndex < 0) {
+                insertionIndex = (insertionIndex * -1) - 1;
+            }
+            this.childrenProperties.splice(insertionIndex, 0, childProperty);
+        }
+        else {
+            this.childrenProperties.push(childProperty);
+        }
+        return childProperty;
+    }
+}
+function compareProperties(propertyTree1, propertyTree2) {
+    if (propertyTree1.propertyName < propertyTree2.propertyName) {
+        return -1;
+    }
+    else if (propertyTree1.propertyName > propertyTree2.propertyName) {
+        return 1;
+    }
+    return 0;
+}
+function binarySearchOnPropertyArray(propertyTreeArray, propertyTree, compare_fn) {
+    if (propertyTree.propertyName < propertyTreeArray[0].propertyName) {
+        return 0;
+    }
+    if (propertyTree.propertyName > propertyTreeArray[propertyTreeArray.length - 1].propertyName) {
+        return propertyTreeArray.length;
+    }
+    let m = 0;
+    let n = propertyTreeArray.length - 1;
+    while (m <= n) {
+        let k = (n + m) >> 1;
+        let cmp = compare_fn(propertyTree, propertyTreeArray[k]);
+        if (cmp > 0) {
+            m = k + 1;
+        }
+        else if (cmp < 0) {
+            n = k - 1;
+        }
+        else {
+            return k;
+        }
+    }
+    return -m - 1;
+}