vscode-json-languageservice 3.4.12 → 3.7.0

package/lib/umd/services/jsonSchemaService.js

@@ -20,24 +20,40 @@
     var nls = require("vscode-nls");
     var localize = nls.loadMessageBundle();
     var FilePatternAssociation = /** @class */ (function () {
-        function FilePatternAssociation(pattern) {
+        function FilePatternAssociation(pattern, uris) {
+            this.patternRegExps = [];
+            this.isInclude = [];
             try {
-                this.patternRegExp = new RegExp(Strings.convertSimple2RegExpPattern(pattern) + '$');
+                for (var _i = 0, pattern_1 = pattern; _i < pattern_1.length; _i++) {
+                    var p = pattern_1[_i];
+                    var include = p[0] !== '!';
+                    if (!include) {
+                        p = p.substring(1);
+                    }
+                    this.patternRegExps.push(new RegExp(Strings.convertSimple2RegExpPattern(p) + '$'));
+                    this.isInclude.push(include);
+                }
+                this.uris = uris;
             }
             catch (e) {
                 // invalid pattern
-                this.patternRegExp = null;
+                this.patternRegExps.length = 0;
+                this.isInclude.length = 0;
+                this.uris = [];
             }
-            this.schemas = [];
         }
-        FilePatternAssociation.prototype.addSchema = function (id) {
-            this.schemas.push(id);
-        };
         FilePatternAssociation.prototype.matchesPattern = function (fileName) {
-            return this.patternRegExp && this.patternRegExp.test(fileName);
+            var match = false;
+            for (var i = 0; i < this.patternRegExps.length; i++) {
+                var regExp = this.patternRegExps[i];
+                if (regExp.test(fileName)) {
+                    match = this.isInclude[i];
+                }
+            }
+            return match;
         };
-        FilePatternAssociation.prototype.getSchemas = function () {
-            return this.schemas;
+        FilePatternAssociation.prototype.getURIs = function () {
+            return this.uris;
         };
         return FilePatternAssociation;
     }());
@@ -66,8 +82,8 @@
             return this.resolvedSchema;
         };
         SchemaHandle.prototype.clearSchema = function () {
-            this.resolvedSchema = null;
-            this.unresolvedSchema = null;
+            this.resolvedSchema = undefined;
+            this.unresolvedSchema = undefined;
             this.dependencies = {};
         };
         return SchemaHandle;
@@ -88,7 +104,11 @@
             this.errors = errors;
         }
         ResolvedSchema.prototype.getSection = function (path) {
-            return Parser.asSchema(this.getSectionRecursive(path, this.schema));
+            var schemaRef = this.getSectionRecursive(path, this.schema);
+            if (schemaRef) {
+                return Parser.asSchema(schemaRef);
+            }
+            return undefined;
         };
         ResolvedSchema.prototype.getSectionRecursive = function (path, schema) {
             if (!schema || typeof schema === 'boolean' || path.length === 0) {
@@ -121,7 +141,7 @@
                     return this.getSectionRecursive(path, schema.items);
                 }
             }
-            return null;
+            return undefined;
         };
         return ResolvedSchema;
     }());
@@ -133,10 +153,9 @@
             this.promiseConstructor = promiseConstructor || Promise;
             this.callOnDispose = [];
             this.contributionSchemas = {};
-            this.contributionAssociations = {};
+            this.contributionAssociations = [];
             this.schemasById = {};
             this.filePatternAssociations = [];
-            this.filePatternAssociationById = {};
             this.registeredSchemasIds = {};
         }
         JSONSchemaService.prototype.getRegisteredSchemaIds = function (filter) {
@@ -160,7 +179,7 @@
         JSONSchemaService.prototype.onResourceChange = function (uri) {
             var _this = this;
             var hasChanges = false;
-            uri = this.normalizeId(uri);
+            uri = normalizeId(uri);
             var toWalk = [uri];
             var all = Object.keys(this.schemasById).map(function (key) { return _this.schemasById[key]; });
             while (toWalk.length) {
@@ -179,34 +198,21 @@
             }
             return hasChanges;
         };
-        JSONSchemaService.prototype.normalizeId = function (id) {
-            // remove trailing '#', normalize drive capitalization
-            try {
-                return vscode_uri_1.URI.parse(id).toString();
-            }
-            catch (e) {
-                return id;
-            }
-        };
         JSONSchemaService.prototype.setSchemaContributions = function (schemaContributions) {
             if (schemaContributions.schemas) {
                 var schemas = schemaContributions.schemas;
                 for (var id in schemas) {
-                    var normalizedId = this.normalizeId(id);
+                    var normalizedId = normalizeId(id);
                     this.contributionSchemas[normalizedId] = this.addSchemaHandle(normalizedId, schemas[id]);
                 }
             }
-            if (schemaContributions.schemaAssociations) {
+            if (Array.isArray(schemaContributions.schemaAssociations)) {
                 var schemaAssociations = schemaContributions.schemaAssociations;
-                for (var pattern in schemaAssociations) {
-                    var associations = schemaAssociations[pattern];
-                    this.contributionAssociations[pattern] = associations;
-                    var fpa = this.getOrAddFilePatternAssociation(pattern);
-                    for (var _i = 0, associations_1 = associations; _i < associations_1.length; _i++) {
-                        var schemaId = associations_1[_i];
-                        var id = this.normalizeId(schemaId);
-                        fpa.addSchema(id);
-                    }
+                for (var _i = 0, schemaAssociations_1 = schemaAssociations; _i < schemaAssociations_1.length; _i++) {
+                    var schemaAssociation = schemaAssociations_1[_i];
+                    var uris = schemaAssociation.uris.map(normalizeId);
+                    var association = this.addFilePatternAssociation(schemaAssociation.pattern, uris);
+                    this.contributionAssociations.push(association);
                 }
             }
         };
@@ -218,52 +224,41 @@
         JSONSchemaService.prototype.getOrAddSchemaHandle = function (id, unresolvedSchemaContent) {
             return this.schemasById[id] || this.addSchemaHandle(id, unresolvedSchemaContent);
         };
-        JSONSchemaService.prototype.getOrAddFilePatternAssociation = function (pattern) {
-            var fpa = this.filePatternAssociationById[pattern];
-            if (!fpa) {
-                fpa = new FilePatternAssociation(pattern);
-                this.filePatternAssociationById[pattern] = fpa;
-                this.filePatternAssociations.push(fpa);
-            }
+        JSONSchemaService.prototype.addFilePatternAssociation = function (pattern, uris) {
+            var fpa = new FilePatternAssociation(pattern, uris);
+            this.filePatternAssociations.push(fpa);
             return fpa;
         };
         JSONSchemaService.prototype.registerExternalSchema = function (uri, filePatterns, unresolvedSchemaContent) {
-            if (filePatterns === void 0) { filePatterns = null; }
-            var id = this.normalizeId(uri);
+            var id = normalizeId(uri);
             this.registeredSchemasIds[id] = true;
+            this.cachedSchemaForResource = undefined;
             if (filePatterns) {
-                for (var _i = 0, filePatterns_1 = filePatterns; _i < filePatterns_1.length; _i++) {
-                    var pattern = filePatterns_1[_i];
-                    this.getOrAddFilePatternAssociation(pattern).addSchema(id);
-                }
+                this.addFilePatternAssociation(filePatterns, [uri]);
             }
             return unresolvedSchemaContent ? this.addSchemaHandle(id, unresolvedSchemaContent) : this.getOrAddSchemaHandle(id);
         };
         JSONSchemaService.prototype.clearExternalSchemas = function () {
             this.schemasById = {};
             this.filePatternAssociations = [];
-            this.filePatternAssociationById = {};
             this.registeredSchemasIds = {};
+            this.cachedSchemaForResource = undefined;
             for (var id in this.contributionSchemas) {
                 this.schemasById[id] = this.contributionSchemas[id];
                 this.registeredSchemasIds[id] = true;
             }
-            for (var pattern in this.contributionAssociations) {
-                var fpa = this.getOrAddFilePatternAssociation(pattern);
-                for (var _i = 0, _a = this.contributionAssociations[pattern]; _i < _a.length; _i++) {
-                    var schemaId = _a[_i];
-                    var id = this.normalizeId(schemaId);
-                    fpa.addSchema(id);
-                }
+            for (var _i = 0, _a = this.contributionAssociations; _i < _a.length; _i++) {
+                var contributionAssociation = _a[_i];
+                this.filePatternAssociations.push(contributionAssociation);
             }
         };
         JSONSchemaService.prototype.getResolvedSchema = function (schemaId) {
-            var id = this.normalizeId(schemaId);
+            var id = normalizeId(schemaId);
             var schemaHandle = this.schemasById[id];
             if (schemaHandle) {
                 return schemaHandle.getResolvedSchema();
             }
-            return this.promise.resolve(null);
+            return this.promise.resolve(undefined);
         };
         JSONSchemaService.prototype.loadSchema = function (url) {
             if (!this.requestService) {
@@ -298,7 +293,7 @@
             var resolveErrors = schemaToResolve.errors.slice(0);
             var schema = schemaToResolve.schema;
             if (schema.$schema) {
-                var id = this.normalizeId(schema.$schema);
+                var id = normalizeId(schema.$schema);
                 if (id === 'http://json-schema.org/draft-03/schema') {
                     return this.promise.resolve(new ResolvedSchema({}, [localize('json.schema.draft03.notsupported', "Draft-03 schemas are not supported.")]));
                 }
@@ -321,7 +316,8 @@
                 });
                 return current;
             };
-            var merge = function (target, sourceRoot, sourceURI, path) {
+            var merge = function (target, sourceRoot, sourceURI, refSegment) {
+                var path = refSegment ? decodeURIComponent(refSegment) : undefined;
                 var section = findSection(sourceRoot, path);
                 if (section) {
                     for (var key in section) {
@@ -334,19 +330,19 @@
                     resolveErrors.push(localize('json.schema.invalidref', '$ref \'{0}\' in \'{1}\' can not be resolved.', path, sourceURI));
                 }
             };
-            var resolveExternalLink = function (node, uri, linkPath, parentSchemaURL, parentSchemaDependencies) {
+            var resolveExternalLink = function (node, uri, refSegment, parentSchemaURL, parentSchemaDependencies) {
                 if (contextService && !/^\w+:\/\/.*/.test(uri)) {
                     uri = contextService.resolveRelativePath(uri, parentSchemaURL);
                 }
-                uri = _this.normalizeId(uri);
+                uri = normalizeId(uri);
                 var referencedHandle = _this.getOrAddSchemaHandle(uri);
                 return referencedHandle.getUnresolvedSchema().then(function (unresolvedSchema) {
                     parentSchemaDependencies[uri] = true;
                     if (unresolvedSchema.errors.length) {
-                        var loc = linkPath ? uri + '#' + linkPath : uri;
+                        var loc = refSegment ? uri + '#' + refSegment : uri;
                         resolveErrors.push(localize('json.schema.problemloadingref', 'Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0]));
                     }
-                    merge(node, unresolvedSchema.schema, uri, linkPath);
+                    merge(node, unresolvedSchema.schema, uri, refSegment);
                     return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);
                 });
             };
@@ -377,7 +373,8 @@
                     for (var _a = 0, maps_1 = maps; _a < maps_1.length; _a++) {
                         var map = maps_1[_a];
                         if (typeof map === 'object') {
-                            for (var key in map) {
+                            for (var k in map) {
+                                var key = k;
                                 var entry = map[key];
                                 if (typeof entry === 'object') {
                                     toWalk.push(entry);
@@ -441,22 +438,28 @@
             if (document && document.root && document.root.type === 'object') {
                 var schemaProperties = document.root.properties.filter(function (p) { return (p.keyNode.value === '$schema') && p.valueNode && p.valueNode.type === 'string'; });
                 if (schemaProperties.length > 0) {
-                    var schemeId = Parser.getNodeValue(schemaProperties[0].valueNode);
-                    if (schemeId && Strings.startsWith(schemeId, '.') && this.contextService) {
-                        schemeId = this.contextService.resolveRelativePath(schemeId, resource);
-                    }
-                    if (schemeId) {
-                        var id = this.normalizeId(schemeId);
-                        return this.getOrAddSchemaHandle(id).getResolvedSchema();
+                    var valueNode = schemaProperties[0].valueNode;
+                    if (valueNode && valueNode.type === 'string') {
+                        var schemeId = Parser.getNodeValue(valueNode);
+                        if (schemeId && Strings.startsWith(schemeId, '.') && this.contextService) {
+                            schemeId = this.contextService.resolveRelativePath(schemeId, resource);
+                        }
+                        if (schemeId) {
+                            var id = normalizeId(schemeId);
+                            return this.getOrAddSchemaHandle(id).getResolvedSchema();
+                        }
                     }
                 }
             }
+            if (this.cachedSchemaForResource && this.cachedSchemaForResource.resource === resource) {
+                return this.cachedSchemaForResource.resolvedSchema;
+            }
             var seen = Object.create(null);
             var schemas = [];
             for (var _i = 0, _a = this.filePatternAssociations; _i < _a.length; _i++) {
                 var entry = _a[_i];
                 if (entry.matchesPattern(resource)) {
-                    for (var _b = 0, _c = entry.getSchemas(); _b < _c.length; _b++) {
+                    for (var _b = 0, _c = entry.getURIs(); _b < _c.length; _b++) {
                         var schemaId = _c[_b];
                         if (!seen[schemaId]) {
                             schemas.push(schemaId);
@@ -465,10 +468,9 @@
                     }
                 }
             }
-            if (schemas.length > 0) {
-                return this.createCombinedSchema(resource, schemas).getResolvedSchema();
-            }
-            return this.promise.resolve(null);
+            var resolvedSchema = schemas.length > 0 ? this.createCombinedSchema(resource, schemas).getResolvedSchema() : this.promise.resolve(undefined);
+            this.cachedSchemaForResource = { resource: resource, resolvedSchema: resolvedSchema };
+            return resolvedSchema;
         };
         JSONSchemaService.prototype.createCombinedSchema = function (resource, schemaIds) {
             if (schemaIds.length === 1) {
@@ -485,6 +487,15 @@
         return JSONSchemaService;
     }());
     exports.JSONSchemaService = JSONSchemaService;
+    function normalizeId(id) {
+        // remove trailing '#', normalize drive capitalization
+        try {
+            return vscode_uri_1.URI.parse(id).toString();
+        }
+        catch (e) {
+            return id;
+        }
+    }
     function toDisplayString(url) {
         try {
             var uri = vscode_uri_1.URI.parse(url);

package/lib/umd/services/jsonValidation.js

@@ -27,7 +27,7 @@
         JSONValidation.prototype.configure = function (raw) {
             if (raw) {
                 this.validationEnabled = raw.validate;
-                this.commentSeverity = raw.allowComments ? void 0 : jsonLanguageTypes_1.DiagnosticSeverity.Error;
+                this.commentSeverity = raw.allowComments ? undefined : jsonLanguageTypes_1.DiagnosticSeverity.Error;
             }
         };
         JSONValidation.prototype.doValidation = function (textDocument, jsonDocument, documentSettings, schema) {
@@ -51,7 +51,7 @@
                 if (schema) {
                     if (schema.errors.length && jsonDocument.root) {
                         var astRoot = jsonDocument.root;
-                        var property = astRoot.type === 'object' ? astRoot.properties[0] : null;
+                        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));
@@ -69,10 +69,10 @@
                         }
                     }
                     if (schemaAllowsComments(schema.schema)) {
-                        commentSeverity = void 0;
+                        commentSeverity = undefined;
                     }
                     if (schemaAllowsTrailingCommas(schema.schema)) {
-                        trailingCommaSeverity = void 0;
+                        trailingCommaSeverity = undefined;
                     }
                 }
                 for (var _i = 0, _a = jsonDocument.syntaxErrors; _i < _a.length; _i++) {
@@ -129,8 +129,9 @@
             if (objects_1.isBoolean(schemaRef.allowTrailingCommas)) {
                 return schemaRef.allowTrailingCommas;
             }
-            if (objects_1.isBoolean(schemaRef['allowsTrailingCommas'])) { // deprecated
-                return schemaRef['allowsTrailingCommas'];
+            var deprSchemaRef = schemaRef;
+            if (objects_1.isBoolean(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
+                return deprSchemaRef['allowsTrailingCommas'];
             }
             if (schemaRef.allOf) {
                 for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
@@ -148,8 +149,8 @@
         switch (severityLevel) {
             case 'error': return jsonLanguageTypes_1.DiagnosticSeverity.Error;
             case 'warning': return jsonLanguageTypes_1.DiagnosticSeverity.Warning;
-            case 'ignore': return void 0;
+            case 'ignore': return undefined;
         }
-        return void 0;
+        return undefined;
     }
 });

package/lib/umd/utils/colors.js

@@ -36,7 +36,7 @@
     exports.hexDigit = hexDigit;
     function colorFromHex(text) {
         if (text[0] !== '#') {
-            return null;
+            return undefined;
         }
         switch (text.length) {
             case 4:
@@ -68,7 +68,7 @@
                     alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
                 };
         }
-        return null;
+        return undefined;
     }
     exports.colorFromHex = colorFromHex;
     function colorFrom256RGB(red, green, blue, alpha) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vscode-json-languageservice",
-  "version": "3.4.12",
+  "version": "3.7.0",
   "description": "Language service for JSON",
   "main": "./lib/umd/jsonLanguageService.js",
   "typings": "./lib/umd/jsonLanguageService",
@@ -15,19 +15,22 @@
     "url": "https://github.com/Microsoft/vscode-json-languageservice"
   },
   "devDependencies": {
-    "@types/mocha": "^5.2.7",
+    "@types/mocha": "^7.0.2",
     "@types/node": "^10.12.21",
-    "mocha": "^7.0.0",
-    "rimraf": "^3.0.0",
-    "tslint": "^6.0.0",
-    "typescript": "^3.7.5"
+    "@typescript-eslint/eslint-plugin": "^3.1.0",
+    "@typescript-eslint/parser": "^3.1.0",
+    "eslint": "^7.1.0",
+    "mocha": "^7.2.0",
+    "nyc": "^15.0.1",
+    "rimraf": "^3.0.2",
+    "typescript": "^3.8.3"
   },
   "dependencies": {
-    "jsonc-parser": "^2.2.0",
-    "vscode-languageserver-textdocument": "^1.0.1-next.1",
-    "vscode-languageserver-types": "^3.15.0",
-    "vscode-nls": "^4.1.1",
-    "vscode-uri": "^2.1.1"
+    "jsonc-parser": "^2.2.1",
+    "vscode-languageserver-textdocument": "^1.0.1",
+    "vscode-languageserver-types": "^3.15.1",
+    "vscode-nls": "^4.1.2",
+    "vscode-uri": "^2.1.2"
   },
   "scripts": {
     "prepublishOnly": "npm run clean && npm run compile-esm && npm run test && npm run remove-sourcemap-refs",
@@ -37,8 +40,11 @@
     "clean": "rimraf lib",
     "remove-sourcemap-refs": "node ./build/remove-sourcemap-refs.js",
     "watch": "tsc -w -p ./src",
-    "test": "npm run compile && mocha && npm run lint",
-    "lint": "tslint src/**/*.ts",
+    "pretest": "npm run compile",
+    "test": "mocha",
+    "posttest": "npm run lint",
+    "coverage": "nyc -r lcov npm run test",
+    "lint": "eslint src/**/*.ts",
     "install-types-next": "npm install vscode-languageserver-types@next -f -S && npm install vscode-languageserver-textdocument@next -f -S",
     "preversion": "npm test",
     "postversion": "git push && git push --tags"