vscode-json-languageservice 4.2.0-next.0 → 4.2.0

package/lib/umd/services/jsonSchemaService.js

@@ -38,7 +38,7 @@
                             patternString = patternString.substring(1);
                         }
                         this.globWrappers.push({
-                            regexp: glob_1.createRegex('**/' + patternString, { extended: true, globstar: true }),
+                            regexp: (0, glob_1.createRegex)('**/' + patternString, { extended: true, globstar: true }),
                             include: include,
                         });
                     }
@@ -71,6 +71,7 @@
             this.service = service;
             this.uri = uri;
             this.dependencies = new Set();
+            this.anchors = undefined;
             if (unresolvedSchemaContent) {
                 this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(unresolvedSchemaContent));
             }
@@ -85,7 +86,7 @@
             var _this = this;
             if (!this.resolvedSchema) {
                 this.resolvedSchema = this.getUnresolvedSchema().then(function (unresolved) {
-                    return _this.service.resolveSchemaContent(unresolved, _this.uri, _this.dependencies);
+                    return _this.service.resolveSchemaContent(unresolved, _this);
                 });
             }
             return this.resolvedSchema;
@@ -95,6 +96,7 @@
             this.resolvedSchema = undefined;
             this.unresolvedSchema = undefined;
             this.dependencies.clear();
+            this.anchors = undefined;
             return hasChanges;
         };
         return SchemaHandle;
@@ -302,7 +304,7 @@
                 return new UnresolvedSchema({}, [localize('json.schema.nocontent', 'Unable to load schema from \'{0}\': {1}.', toDisplayString(url), errorMessage)]);
             });
         };
-        JSONSchemaService.prototype.resolveSchemaContent = function (schemaToResolve, schemaURL, dependencies) {
+        JSONSchemaService.prototype.resolveSchemaContent = function (schemaToResolve, handle) {
             var _this = this;
             var resolveErrors = schemaToResolve.errors.slice(0);
             var schema = schemaToResolve.schema;
@@ -319,13 +321,11 @@
                 }
             }
             var contextService = this.contextService;
-            var findSection = function (schema, path) {
-                if (!path) {
-                    return schema;
-                }
+            var findSectionByJSONPointer = function (schema, path) {
+                path = decodeURIComponent(path);
                 var current = schema;
                 if (path[0] === '/') {
-                    path = path.substr(1);
+                    path = path.substring(1);
                 }
                 path.split('/').some(function (part) {
                     part = part.replace(/~1/g, '/').replace(/~0/g, '~');
@@ -334,130 +334,179 @@
                 });
                 return current;
             };
-            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) {
-                        if (section.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
-                            target[key] = section[key];
-                        }
+            var findSchemaById = function (schema, handle, id) {
+                if (!handle.anchors) {
+                    handle.anchors = collectAnchors(schema);
+                }
+                return handle.anchors.get(id);
+            };
+            var merge = function (target, section) {
+                for (var key in section) {
+                    if (section.hasOwnProperty(key) && !target.hasOwnProperty(key) && key !== 'id' && key !== '$id') {
+                        target[key] = section[key];
                     }
                 }
+            };
+            var mergeRef = function (target, sourceRoot, sourceHandle, refSegment) {
+                var section;
+                if (refSegment === undefined || refSegment.length === 0) {
+                    section = sourceRoot;
+                }
+                else if (refSegment.charAt(0) === '/') {
+                    // A $ref to a JSON Pointer (i.e #/definitions/foo)
+                    section = findSectionByJSONPointer(sourceRoot, refSegment);
+                }
                 else {
-                    resolveErrors.push(localize('json.schema.invalidref', '$ref \'{0}\' in \'{1}\' can not be resolved.', path, sourceURI));
+                    // A $ref to a sub-schema with an $id (i.e #hello)
+                    section = findSchemaById(sourceRoot, sourceHandle, refSegment);
+                }
+                if (section) {
+                    merge(target, section);
+                }
+                else {
+                    resolveErrors.push(localize('json.schema.invalidid', '$ref \'{0}\' in \'{1}\' can not be resolved.', refSegment, sourceHandle.uri));
                 }
             };
-            var resolveExternalLink = function (node, uri, refSegment, parentSchemaURL, parentSchemaDependencies) {
+            var resolveExternalLink = function (node, uri, refSegment, parentHandle) {
                 if (contextService && !/^[A-Za-z][A-Za-z0-9+\-.+]*:\/\/.*/.test(uri)) {
-                    uri = contextService.resolveRelativePath(uri, parentSchemaURL);
+                    uri = contextService.resolveRelativePath(uri, parentHandle.uri);
                 }
                 uri = normalizeId(uri);
                 var referencedHandle = _this.getOrAddSchemaHandle(uri);
                 return referencedHandle.getUnresolvedSchema().then(function (unresolvedSchema) {
-                    parentSchemaDependencies.add(uri);
+                    parentHandle.dependencies.add(uri);
                     if (unresolvedSchema.errors.length) {
                         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, refSegment);
-                    return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);
+                    mergeRef(node, unresolvedSchema.schema, referencedHandle, refSegment);
+                    return resolveRefs(node, unresolvedSchema.schema, referencedHandle);
                 });
             };
-            var resolveRefs = function (node, parentSchema, parentSchemaURL, parentSchemaDependencies) {
-                if (!node || typeof node !== 'object') {
-                    return Promise.resolve(null);
-                }
-                var toWalk = [node];
-                var seen = new Set();
+            var resolveRefs = function (node, parentSchema, parentHandle) {
                 var openPromises = [];
-                var collectEntries = function () {
-                    var entries = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        entries[_i] = arguments[_i];
-                    }
-                    for (var _a = 0, entries_1 = entries; _a < entries_1.length; _a++) {
-                        var entry = entries_1[_a];
-                        if (typeof entry === 'object') {
-                            toWalk.push(entry);
-                        }
-                    }
-                };
-                var collectMapEntries = function () {
-                    var maps = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        maps[_i] = arguments[_i];
-                    }
-                    for (var _a = 0, maps_1 = maps; _a < maps_1.length; _a++) {
-                        var map = maps_1[_a];
-                        if (typeof map === 'object') {
-                            for (var k in map) {
-                                var key = k;
-                                var entry = map[key];
-                                if (typeof entry === 'object') {
-                                    toWalk.push(entry);
-                                }
-                            }
-                        }
-                    }
-                };
-                var collectArrayEntries = function () {
-                    var arrays = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        arrays[_i] = arguments[_i];
-                    }
-                    for (var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++) {
-                        var array = arrays_1[_a];
-                        if (Array.isArray(array)) {
-                            for (var _b = 0, array_1 = array; _b < array_1.length; _b++) {
-                                var entry = array_1[_b];
-                                if (typeof entry === 'object') {
-                                    toWalk.push(entry);
-                                }
-                            }
-                        }
-                    }
-                };
-                var handleRef = function (next) {
+                _this.traverseNodes(node, function (next) {
                     var seenRefs = new Set();
                     while (next.$ref) {
                         var ref = next.$ref;
                         var segments = ref.split('#', 2);
                         delete next.$ref;
                         if (segments[0].length > 0) {
-                            openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));
+                            // This is a reference to an external schema
+                            openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentHandle));
                             return;
                         }
                         else {
+                            // This is a reference inside the current schema
                             if (!seenRefs.has(ref)) {
-                                merge(next, parentSchema, parentSchemaURL, segments[1]); // can set next.$ref again, use seenRefs to avoid circle
+                                var id = segments[1];
+                                mergeRef(next, parentSchema, parentHandle, id);
                                 seenRefs.add(ref);
                             }
                         }
                     }
+                });
+                return _this.promise.all(openPromises);
+            };
+            var collectAnchors = function (root) {
+                var result = new Map();
+                _this.traverseNodes(root, function (next) {
+                    var id = next.$id || next.id;
+                    if (typeof id === 'string' && id.charAt(0) === '#') {
+                        // delete next.$id;
+                        // delete next.id;
+                        var anchor = id.substring(1);
+                        if (result.has(anchor)) {
+                            resolveErrors.push(localize('json.schema.duplicateid', 'Duplicate id declaration: \'{0}\'', id));
+                        }
+                        else {
+                            result.set(anchor, next);
+                        }
+                    }
+                });
+                return result;
+            };
+            return resolveRefs(schema, schema, handle).then(function (_) {
+                return new ResolvedSchema(schema, resolveErrors);
+            });
+        };
+        JSONSchemaService.prototype.traverseNodes = function (root, handle) {
+            if (!root || typeof root !== 'object') {
+                return Promise.resolve(null);
+            }
+            var seen = new Set();
+            var collectEntries = function () {
+                var entries = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    entries[_i] = arguments[_i];
+                }
+                for (var _a = 0, entries_1 = entries; _a < entries_1.length; _a++) {
+                    var entry = entries_1[_a];
+                    if (typeof entry === 'object') {
+                        toWalk.push(entry);
+                    }
+                }
+            };
+            var collectMapEntries = function () {
+                var maps = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    maps[_i] = arguments[_i];
+                }
+                for (var _a = 0, maps_1 = maps; _a < maps_1.length; _a++) {
+                    var map = maps_1[_a];
+                    if (typeof map === 'object') {
+                        for (var k in map) {
+                            var key = k;
+                            var entry = map[key];
+                            if (typeof entry === 'object') {
+                                toWalk.push(entry);
+                            }
+                        }
+                    }
+                }
+            };
+            var collectArrayEntries = function () {
+                var arrays = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    arrays[_i] = arguments[_i];
+                }
+                for (var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++) {
+                    var array = arrays_1[_a];
+                    if (Array.isArray(array)) {
+                        for (var _b = 0, array_1 = array; _b < array_1.length; _b++) {
+                            var entry = array_1[_b];
+                            if (typeof entry === 'object') {
+                                toWalk.push(entry);
+                            }
+                        }
+                    }
+                }
+            };
+            var toWalk = [root];
+            var next = toWalk.pop();
+            while (next) {
+                if (!seen.has(next)) {
+                    seen.add(next);
+                    handle(next);
                     collectEntries(next.items, next.additionalItems, next.additionalProperties, next.not, next.contains, next.propertyNames, next.if, next.then, next.else);
                     collectMapEntries(next.definitions, next.properties, next.patternProperties, next.dependencies);
                     collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.items);
-                };
-                while (toWalk.length) {
-                    var next = toWalk.pop();
-                    if (seen.has(next)) {
-                        continue;
-                    }
-                    seen.add(next);
-                    handleRef(next);
                 }
-                return _this.promise.all(openPromises);
-            };
-            return resolveRefs(schema, schema, schemaURL, dependencies).then(function (_) { return new ResolvedSchema(schema, resolveErrors); });
+                next = toWalk.pop();
+            }
         };
-        JSONSchemaService.prototype.getSchemaProperty = function (document) {
+        ;
+        JSONSchemaService.prototype.getSchemaFromProperty = function (resource, document) {
             var _a, _b;
             if (((_a = document.root) === null || _a === void 0 ? void 0 : _a.type) === 'object') {
                 for (var _i = 0, _c = document.root.properties; _i < _c.length; _i++) {
                     var p = _c[_i];
                     if (p.keyNode.value === '$schema' && ((_b = p.valueNode) === null || _b === void 0 ? void 0 : _b.type) === 'string') {
-                        return p.valueNode.value;
+                        var schemaId = p.valueNode.value;
+                        if (this.contextService && !/^\w[\w\d+.-]*:/.test(schemaId)) { // has scheme
+                            schemaId = this.contextService.resolveRelativePath(schemaId, resource);
+                        }
+                        return schemaId;
                     }
                 }
             }
@@ -482,7 +531,7 @@
             return schemas;
         };
         JSONSchemaService.prototype.getSchemaURIsForResource = function (resource, document) {
-            var schemeId = document && this.getSchemaProperty(document);
+            var schemeId = document && this.getSchemaFromProperty(resource, document);
             if (schemeId) {
                 return [schemeId];
             }
@@ -491,10 +540,7 @@
         JSONSchemaService.prototype.getSchemaForResource = function (resource, document) {
             if (document) {
                 // first use $schema if present
-                var schemeId = this.getSchemaProperty(document);
-                if (schemeId && Strings.startsWith(schemeId, '.') && this.contextService) {
-                    schemeId = this.contextService.resolveRelativePath(schemeId, resource);
-                }
+                var schemeId = this.getSchemaFromProperty(resource, document);
                 if (schemeId) {
                     var id = normalizeId(schemeId);
                     return this.getOrAddSchemaHandle(id).getResolvedSchema();
@@ -523,7 +569,8 @@
         JSONSchemaService.prototype.getMatchingSchemas = function (document, jsonDocument, schema) {
             if (schema) {
                 var id = schema.id || ('schemaservice://untitled/matchingSchemas/' + idCounter++);
-                return this.resolveSchemaContent(new UnresolvedSchema(schema), id, new Set()).then(function (resolvedSchema) {
+                var handle = this.addSchemaHandle(id, schema);
+                return handle.getResolvedSchema().then(function (resolvedSchema) {
                     return jsonDocument.getMatchingSchemas(resolvedSchema.schema).filter(function (s) { return !s.inverted; });
                 });
             }

package/lib/umd/services/jsonSelectionRanges.js

@@ -60,7 +60,7 @@
         function newRange(start, end) {
             return jsonLanguageTypes_1.Range.create(document.positionAt(start), document.positionAt(end));
         }
-        var scanner = jsonc_parser_1.createScanner(document.getText(), true);
+        var scanner = (0, jsonc_parser_1.createScanner)(document.getText(), true);
         function getOffsetAfterNextToken(offset, expectedToken) {
             scanner.setPosition(offset);
             var token = scanner.scan();

package/lib/umd/services/jsonValidation.js

@@ -8,13 +8,12 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./jsonSchemaService", "../jsonLanguageTypes", "vscode-nls", "../utils/objects"], factory);
+        define(["require", "exports", "../jsonLanguageTypes", "vscode-nls", "../utils/objects"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JSONValidation = void 0;
-    var jsonSchemaService_1 = require("./jsonSchemaService");
     var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
     var nls = require("vscode-nls");
     var objects_1 = require("../utils/objects");
@@ -98,7 +97,8 @@
             };
             if (schema) {
                 var id = schema.id || ('schemaservice://untitled/' + idCounter++);
-                return this.jsonSchemaService.resolveSchemaContent(new jsonSchemaService_1.UnresolvedSchema(schema), id, new Set()).then(function (resolvedSchema) {
+                var handle = this.jsonSchemaService.registerExternalSchema(id, [], schema);
+                return handle.getResolvedSchema().then(function (resolvedSchema) {
                     return getDiagnostics(resolvedSchema);
                 });
             }
@@ -115,14 +115,14 @@
     var idCounter = 0;
     function schemaAllowsComments(schemaRef) {
         if (schemaRef && typeof schemaRef === 'object') {
-            if (objects_1.isBoolean(schemaRef.allowComments)) {
+            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);
-                    if (objects_1.isBoolean(allow)) {
+                    if ((0, objects_1.isBoolean)(allow)) {
                         return allow;
                     }
                 }
@@ -132,18 +132,18 @@
     }
     function schemaAllowsTrailingCommas(schemaRef) {
         if (schemaRef && typeof schemaRef === 'object') {
-            if (objects_1.isBoolean(schemaRef.allowTrailingCommas)) {
+            if ((0, objects_1.isBoolean)(schemaRef.allowTrailingCommas)) {
                 return schemaRef.allowTrailingCommas;
             }
             var deprSchemaRef = schemaRef;
-            if (objects_1.isBoolean(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
+            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);
-                    if (objects_1.isBoolean(allow)) {
+                    if ((0, objects_1.isBoolean)(allow)) {
                         return allow;
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vscode-json-languageservice",
-  "version": "4.2.0-next.0",
+  "version": "4.2.0",
   "description": "Language service for JSON",
   "main": "./lib/umd/jsonLanguageService.js",
   "typings": "./lib/umd/jsonLanguageService",
@@ -15,21 +15,21 @@
     "url": "https://github.com/Microsoft/vscode-json-languageservice"
   },
   "devDependencies": {
-    "@types/mocha": "^9.0.0",
+    "@types/mocha": "^9.1.0",
     "@types/node": "^10.12.21",
-    "@typescript-eslint/eslint-plugin": "^4.32.0",
-    "@typescript-eslint/parser": "^4.32.0",
-    "eslint": "^7.32.0",
-    "mocha": "^9.1.2",
+    "@typescript-eslint/eslint-plugin": "^5.10.1",
+    "@typescript-eslint/parser": "^5.10.1",
+    "eslint": "^8.7.0",
+    "mocha": "^9.2.0",
     "rimraf": "^3.0.2",
-    "typescript": "^4.1.3"
+    "typescript": "^4.5.5"
   },
   "dependencies": {
     "jsonc-parser": "^3.0.0",
-    "vscode-languageserver-textdocument": "^1.0.1",
+    "vscode-languageserver-textdocument": "^1.0.3",
     "vscode-languageserver-types": "^3.16.0",
     "vscode-nls": "^5.0.0",
-    "vscode-uri": "^3.0.2"
+    "vscode-uri": "^3.0.3"
   },
   "scripts": {
     "prepublishOnly": "npm run clean && npm run compile-esm && npm run test && npm run remove-sourcemap-refs",