vscode-json-languageservice 4.2.0 → 5.1.0

package/lib/umd/services/jsonSelectionRanges.js

@@ -14,20 +14,20 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.getSelectionRanges = void 0;
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    var jsonc_parser_1 = require("jsonc-parser");
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    const jsonc_parser_1 = require("jsonc-parser");
     function getSelectionRanges(document, positions, doc) {
         function getSelectionRange(position) {
-            var offset = document.offsetAt(position);
-            var node = doc.getNodeFromOffset(offset, true);
-            var result = [];
+            let offset = document.offsetAt(position);
+            let node = doc.getNodeFromOffset(offset, true);
+            const result = [];
             while (node) {
                 switch (node.type) {
                     case 'string':
                     case 'object':
                     case 'array':
                         // range without ", [ or {
-                        var cStart = node.offset + 1, cEnd = node.offset + node.length - 1;
+                        const cStart = node.offset + 1, cEnd = node.offset + node.length - 1;
                         if (cStart < cEnd && offset >= cStart && offset <= cEnd) {
                             result.push(newRange(cStart, cEnd));
                         }
@@ -41,15 +41,15 @@
                         break;
                 }
                 if (node.type === 'property' || node.parent && node.parent.type === 'array') {
-                    var afterCommaOffset = getOffsetAfterNextToken(node.offset + node.length, 5 /* CommaToken */);
+                    const afterCommaOffset = getOffsetAfterNextToken(node.offset + node.length, 5 /* SyntaxKind.CommaToken */);
                     if (afterCommaOffset !== -1) {
                         result.push(newRange(node.offset, afterCommaOffset));
                     }
                 }
                 node = node.parent;
             }
-            var current = undefined;
-            for (var index = result.length - 1; index >= 0; index--) {
+            let current = undefined;
+            for (let index = result.length - 1; index >= 0; index--) {
                 current = jsonLanguageTypes_1.SelectionRange.create(result[index], current);
             }
             if (!current) {
@@ -60,10 +60,10 @@
         function newRange(start, end) {
             return jsonLanguageTypes_1.Range.create(document.positionAt(start), document.positionAt(end));
         }
-        var scanner = (0, jsonc_parser_1.createScanner)(document.getText(), true);
+        const scanner = (0, jsonc_parser_1.createScanner)(document.getText(), true);
         function getOffsetAfterNextToken(offset, expectedToken) {
             scanner.setPosition(offset);
-            var token = scanner.scan();
+            let token = scanner.scan();
             if (token === expectedToken) {
                 return scanner.getTokenOffset() + scanner.getTokenLength();
             }

package/lib/umd/services/jsonValidation.js

@@ -14,58 +14,65 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JSONValidation = void 0;
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    var nls = require("vscode-nls");
-    var objects_1 = require("../utils/objects");
-    var localize = nls.loadMessageBundle();
-    var JSONValidation = /** @class */ (function () {
-        function JSONValidation(jsonSchemaService, promiseConstructor) {
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    const nls = require("vscode-nls");
+    const objects_1 = require("../utils/objects");
+    const localize = nls.loadMessageBundle();
+    class JSONValidation {
+        constructor(jsonSchemaService, promiseConstructor) {
             this.jsonSchemaService = jsonSchemaService;
             this.promise = promiseConstructor;
             this.validationEnabled = true;
         }
-        JSONValidation.prototype.configure = function (raw) {
+        configure(raw) {
             if (raw) {
                 this.validationEnabled = raw.validate !== false;
                 this.commentSeverity = raw.allowComments ? undefined : jsonLanguageTypes_1.DiagnosticSeverity.Error;
             }
-        };
-        JSONValidation.prototype.doValidation = function (textDocument, jsonDocument, documentSettings, schema) {
-            var _this = this;
+        }
+        doValidation(textDocument, jsonDocument, documentSettings, schema) {
             if (!this.validationEnabled) {
                 return this.promise.resolve([]);
             }
-            var diagnostics = [];
-            var added = {};
-            var addProblem = function (problem) {
+            const diagnostics = [];
+            const added = {};
+            const addProblem = (problem) => {
                 // remove duplicated messages
-                var signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
+                const signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
                 if (!added[signature]) {
                     added[signature] = true;
                     diagnostics.push(problem);
                 }
             };
-            var getDiagnostics = function (schema) {
-                var trailingCommaSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.trailingCommas) ? toDiagnosticSeverity(documentSettings.trailingCommas) : jsonLanguageTypes_1.DiagnosticSeverity.Error;
-                var commentSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.comments) ? toDiagnosticSeverity(documentSettings.comments) : _this.commentSeverity;
-                var schemaValidation = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaValidation) ? toDiagnosticSeverity(documentSettings.schemaValidation) : jsonLanguageTypes_1.DiagnosticSeverity.Warning;
-                var schemaRequest = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaRequest) ? toDiagnosticSeverity(documentSettings.schemaRequest) : jsonLanguageTypes_1.DiagnosticSeverity.Warning;
+            const getDiagnostics = (schema) => {
+                let trailingCommaSeverity = documentSettings?.trailingCommas ? toDiagnosticSeverity(documentSettings.trailingCommas) : jsonLanguageTypes_1.DiagnosticSeverity.Error;
+                let commentSeverity = documentSettings?.comments ? toDiagnosticSeverity(documentSettings.comments) : this.commentSeverity;
+                let schemaValidation = documentSettings?.schemaValidation ? toDiagnosticSeverity(documentSettings.schemaValidation) : jsonLanguageTypes_1.DiagnosticSeverity.Warning;
+                let schemaRequest = documentSettings?.schemaRequest ? toDiagnosticSeverity(documentSettings.schemaRequest) : jsonLanguageTypes_1.DiagnosticSeverity.Warning;
                 if (schema) {
-                    if (schema.errors.length && jsonDocument.root && schemaRequest) {
-                        var astRoot = jsonDocument.root;
-                        var property = astRoot.type === 'object' ? astRoot.properties[0] : undefined;
-                        if (property && property.keyNode.value === '$schema') {
-                            var node = property.valueNode || property;
-                            var range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
-                            addProblem(jsonLanguageTypes_1.Diagnostic.create(range, schema.errors[0], schemaRequest, jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
-                        }
-                        else {
-                            var range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
-                            addProblem(jsonLanguageTypes_1.Diagnostic.create(range, schema.errors[0], schemaRequest, jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
+                    const addSchemaProblem = (errorMessage, errorCode) => {
+                        if (jsonDocument.root && schemaRequest) {
+                            const astRoot = jsonDocument.root;
+                            const property = astRoot.type === 'object' ? astRoot.properties[0] : undefined;
+                            if (property && property.keyNode.value === '$schema') {
+                                const node = property.valueNode || property;
+                                const range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
+                                addProblem(jsonLanguageTypes_1.Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
+                            }
+                            else {
+                                const range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
+                                addProblem(jsonLanguageTypes_1.Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
+                            }
                         }
+                    };
+                    if (schema.errors.length) {
+                        addSchemaProblem(schema.errors[0], jsonLanguageTypes_1.ErrorCode.SchemaResolveError);
                     }
                     else if (schemaValidation) {
-                        var semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation);
+                        for (const warning of schema.warnings) {
+                            addSchemaProblem(warning, jsonLanguageTypes_1.ErrorCode.SchemaUnsupportedFeature);
+                        }
+                        const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation);
                         if (semanticErrors) {
                             semanticErrors.forEach(addProblem);
                         }
@@ -77,8 +84,7 @@
                         trailingCommaSeverity = undefined;
                     }
                 }
-                for (var _i = 0, _a = jsonDocument.syntaxErrors; _i < _a.length; _i++) {
-                    var p = _a[_i];
+                for (const p of jsonDocument.syntaxErrors) {
                     if (p.code === jsonLanguageTypes_1.ErrorCode.TrailingComma) {
                         if (typeof trailingCommaSeverity !== 'number') {
                             continue;
@@ -88,40 +94,38 @@
                     addProblem(p);
                 }
                 if (typeof commentSeverity === 'number') {
-                    var message_1 = localize('InvalidCommentToken', 'Comments are not permitted in JSON.');
-                    jsonDocument.comments.forEach(function (c) {
-                        addProblem(jsonLanguageTypes_1.Diagnostic.create(c, message_1, commentSeverity, jsonLanguageTypes_1.ErrorCode.CommentNotPermitted));
+                    const message = localize('InvalidCommentToken', 'Comments are not permitted in JSON.');
+                    jsonDocument.comments.forEach(c => {
+                        addProblem(jsonLanguageTypes_1.Diagnostic.create(c, message, commentSeverity, jsonLanguageTypes_1.ErrorCode.CommentNotPermitted));
                     });
                 }
                 return diagnostics;
             };
             if (schema) {
-                var id = schema.id || ('schemaservice://untitled/' + idCounter++);
-                var handle = this.jsonSchemaService.registerExternalSchema(id, [], schema);
-                return handle.getResolvedSchema().then(function (resolvedSchema) {
+                const id = schema.id || ('schemaservice://untitled/' + idCounter++);
+                const handle = this.jsonSchemaService.registerExternalSchema(id, [], schema);
+                return handle.getResolvedSchema().then(resolvedSchema => {
                     return getDiagnostics(resolvedSchema);
                 });
             }
-            return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(function (schema) {
+            return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(schema => {
                 return getDiagnostics(schema);
             });
-        };
-        JSONValidation.prototype.getLanguageStatus = function (textDocument, jsonDocument) {
+        }
+        getLanguageStatus(textDocument, jsonDocument) {
             return { schemas: this.jsonSchemaService.getSchemaURIsForResource(textDocument.uri, jsonDocument) };
-        };
-        return JSONValidation;
-    }());
+        }
+    }
     exports.JSONValidation = JSONValidation;
-    var idCounter = 0;
+    let idCounter = 0;
     function schemaAllowsComments(schemaRef) {
         if (schemaRef && typeof schemaRef === 'object') {
             if ((0, objects_1.isBoolean)(schemaRef.allowComments)) {
                 return schemaRef.allowComments;
             }
             if (schemaRef.allOf) {
-                for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
-                    var schema = _a[_i];
-                    var allow = schemaAllowsComments(schema);
+                for (const schema of schemaRef.allOf) {
+                    const allow = schemaAllowsComments(schema);
                     if ((0, objects_1.isBoolean)(allow)) {
                         return allow;
                     }
@@ -135,14 +139,13 @@
             if ((0, objects_1.isBoolean)(schemaRef.allowTrailingCommas)) {
                 return schemaRef.allowTrailingCommas;
             }
-            var deprSchemaRef = schemaRef;
+            const deprSchemaRef = schemaRef;
             if ((0, objects_1.isBoolean)(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
                 return deprSchemaRef['allowsTrailingCommas'];
             }
             if (schemaRef.allOf) {
-                for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
-                    var schema = _a[_i];
-                    var allow = schemaAllowsTrailingCommas(schema);
+                for (const schema of schemaRef.allOf) {
+                    const allow = schemaAllowsTrailingCommas(schema);
                     if ((0, objects_1.isBoolean)(allow)) {
                         return allow;
                     }

package/lib/umd/utils/colors.js

@@ -14,11 +14,11 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.colorFrom256RGB = exports.colorFromHex = exports.hexDigit = void 0;
-    var Digit0 = 48;
-    var Digit9 = 57;
-    var A = 65;
-    var a = 97;
-    var f = 102;
+    const Digit0 = 48;
+    const Digit9 = 57;
+    const A = 65;
+    const a = 97;
+    const f = 102;
     function hexDigit(charCode) {
         if (charCode < Digit0) {
             return 0;
@@ -72,13 +72,12 @@
         return undefined;
     }
     exports.colorFromHex = colorFromHex;
-    function colorFrom256RGB(red, green, blue, alpha) {
-        if (alpha === void 0) { alpha = 1.0; }
+    function colorFrom256RGB(red, green, blue, alpha = 1.0) {
         return {
             red: red / 255.0,
             green: green / 255.0,
             blue: blue / 255.0,
-            alpha: alpha
+            alpha
         };
     }
     exports.colorFrom256RGB = colorFrom256RGB;

package/lib/umd/utils/glob.js

@@ -19,13 +19,13 @@
         if (typeof glob !== 'string') {
             throw new TypeError('Expected a string');
         }
-        var str = String(glob);
+        const str = String(glob);
         // The regexp we are building, as a string.
-        var reStr = "";
+        let reStr = "";
         // Whether we are matching so called "extended" globs (like bash) and should
         // support single character matching, matching ranges of characters, group
         // matching, etc.
-        var extended = opts ? !!opts.extended : false;
+        const extended = opts ? !!opts.extended : false;
         // When globstar is _false_ (default), '/foo/*' is translated a regexp like
         // '^\/foo\/.*$' which will match any string beginning with '/foo/'
         // When globstar is _true_, '/foo/*' is translated to regexp like
@@ -35,14 +35,14 @@
         // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
         // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
         // globstar is _false_
-        var globstar = opts ? !!opts.globstar : false;
+        const globstar = opts ? !!opts.globstar : false;
         // If we are doing extended matching, this boolean is true when we are inside
         // a group (eg {*.html,*.js}), and false otherwise.
-        var inGroup = false;
+        let inGroup = false;
         // RegExp flags (eg "i" ) to pass in to RegExp constructor.
-        var flags = opts && typeof (opts.flags) === "string" ? opts.flags : "";
-        var c;
-        for (var i = 0, len = str.length; i < len; i++) {
+        const flags = opts && typeof (opts.flags) === "string" ? opts.flags : "";
+        let c;
+        for (let i = 0, len = str.length; i < len; i++) {
             c = str[i];
             switch (c) {
                 case "/":
@@ -90,20 +90,20 @@
                 case "*":
                     // Move over all consecutive "*"'s.
                     // Also store the previous and next characters
-                    var prevChar = str[i - 1];
-                    var starCount = 1;
+                    const prevChar = str[i - 1];
+                    let starCount = 1;
                     while (str[i + 1] === "*") {
                         starCount++;
                         i++;
                     }
-                    var nextChar = str[i + 1];
+                    const nextChar = str[i + 1];
                     if (!globstar) {
                         // globstar is disabled, so treat any number of "*" as one
                         reStr += ".*";
                     }
                     else {
                         // globstar is enabled, so determine if this is a globstar segment
-                        var isGlobstar = starCount > 1 // multiple "*"'s
+                        const isGlobstar = starCount > 1 // multiple "*"'s
                             && (prevChar === "/" || prevChar === undefined || prevChar === '{' || prevChar === ',') // from the start of the segment
                             && (nextChar === "/" || nextChar === undefined || nextChar === ',' || nextChar === '}'); // to the end of the segment
                         if (isGlobstar) {

package/lib/umd/utils/json.js

@@ -16,13 +16,13 @@
     exports.stringifyObject = void 0;
     function stringifyObject(obj, indent, stringifyLiteral) {
         if (obj !== null && typeof obj === 'object') {
-            var newIndent = indent + '\t';
+            const newIndent = indent + '\t';
             if (Array.isArray(obj)) {
                 if (obj.length === 0) {
                     return '[]';
                 }
-                var result = '[\n';
-                for (var i = 0; i < obj.length; i++) {
+                let result = '[\n';
+                for (let i = 0; i < obj.length; i++) {
                     result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);
                     if (i < obj.length - 1) {
                         result += ',';
@@ -33,13 +33,13 @@
                 return result;
             }
             else {
-                var keys = Object.keys(obj);
+                const keys = Object.keys(obj);
                 if (keys.length === 0) {
                     return '{}';
                 }
-                var result = '{\n';
-                for (var i = 0; i < keys.length; i++) {
-                    var key = keys[i];
+                let result = '{\n';
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
                     result += newIndent + JSON.stringify(key) + ': ' + stringifyObject(obj[key], newIndent, stringifyLiteral);
                     if (i < keys.length - 1) {
                         result += ',';

package/lib/umd/utils/objects.js

@@ -13,7 +13,7 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.isString = exports.isBoolean = exports.isDefined = exports.isNumber = exports.equals = void 0;
+    exports.isObject = exports.isString = exports.isBoolean = exports.isDefined = exports.isNumber = exports.equals = void 0;
     function equals(one, other) {
         if (one === other) {
             return true;
@@ -80,4 +80,8 @@
         return typeof val === 'string';
     }
     exports.isString = isString;
+    function isObject(val) {
+        return typeof val === 'object' && val !== null && !Array.isArray(val);
+    }
+    exports.isObject = isObject;
 });

package/lib/umd/utils/strings.js

@@ -18,7 +18,7 @@
         if (haystack.length < needle.length) {
             return false;
         }
-        for (var i = 0; i < needle.length; i++) {
+        for (let i = 0; i < needle.length; i++) {
             if (haystack[i] !== needle[i]) {
                 return false;
             }
@@ -30,7 +30,7 @@
      * Determines if haystack ends with needle.
      */
     function endsWith(haystack, needle) {
-        var diff = haystack.length - needle.length;
+        const diff = haystack.length - needle.length;
         if (diff > 0) {
             return haystack.lastIndexOf(needle) === diff;
         }
@@ -59,7 +59,7 @@
     }
     exports.repeat = repeat;
     function extendedRegExp(pattern) {
-        var flags = '';
+        let flags = '';
         if (startsWith(pattern, '(?i)')) {
             pattern = pattern.substring(4);
             flags = 'i';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vscode-json-languageservice",
-  "version": "4.2.0",
+  "version": "5.1.0",
   "description": "Language service for JSON",
   "main": "./lib/umd/jsonLanguageService.js",
   "typings": "./lib/umd/jsonLanguageService",
@@ -15,20 +15,20 @@
     "url": "https://github.com/Microsoft/vscode-json-languageservice"
   },
   "devDependencies": {
-    "@types/mocha": "^9.1.0",
-    "@types/node": "^10.12.21",
-    "@typescript-eslint/eslint-plugin": "^5.10.1",
-    "@typescript-eslint/parser": "^5.10.1",
-    "eslint": "^8.7.0",
-    "mocha": "^9.2.0",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "16.x",
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "@typescript-eslint/parser": "^5.30.6",
+    "eslint": "^8.19.0",
+    "mocha": "^10.0.0",
     "rimraf": "^3.0.2",
-    "typescript": "^4.5.5"
+    "typescript": "^4.7.4"
   },
   "dependencies": {
-    "jsonc-parser": "^3.0.0",
-    "vscode-languageserver-textdocument": "^1.0.3",
-    "vscode-languageserver-types": "^3.16.0",
-    "vscode-nls": "^5.0.0",
+    "jsonc-parser": "^3.1.0",
+    "vscode-languageserver-textdocument": "^1.0.4",
+    "vscode-languageserver-types": "^3.17.1",
+    "vscode-nls": "^5.0.1",
     "vscode-uri": "^3.0.3"
   },
   "scripts": {