vscode-json-languageservice 5.0.0 → 5.1.1

package/lib/esm/services/jsonSelectionRanges.js

@@ -1,61 +1,61 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Range, SelectionRange } from '../jsonLanguageTypes';
-import { createScanner } from 'jsonc-parser';
-export function getSelectionRanges(document, positions, doc) {
-    function getSelectionRange(position) {
-        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 {
-                    const cStart = node.offset + 1, cEnd = node.offset + node.length - 1;
-                    if (cStart < cEnd && offset >= cStart && offset <= cEnd) {
-                        result.push(newRange(cStart, cEnd));
-                    }
-                    result.push(newRange(node.offset, node.offset + node.length));
-                    break;
-                case 'number':
-                case 'boolean':
-                case 'null':
-                case 'property':
-                    result.push(newRange(node.offset, node.offset + node.length));
-                    break;
-            }
-            if (node.type === 'property' || node.parent && node.parent.type === 'array') {
-                const afterCommaOffset = getOffsetAfterNextToken(node.offset + node.length, 5 /* CommaToken */);
-                if (afterCommaOffset !== -1) {
-                    result.push(newRange(node.offset, afterCommaOffset));
-                }
-            }
-            node = node.parent;
-        }
-        let current = undefined;
-        for (let index = result.length - 1; index >= 0; index--) {
-            current = SelectionRange.create(result[index], current);
-        }
-        if (!current) {
-            current = SelectionRange.create(Range.create(position, position));
-        }
-        return current;
-    }
-    function newRange(start, end) {
-        return Range.create(document.positionAt(start), document.positionAt(end));
-    }
-    const scanner = createScanner(document.getText(), true);
-    function getOffsetAfterNextToken(offset, expectedToken) {
-        scanner.setPosition(offset);
-        let token = scanner.scan();
-        if (token === expectedToken) {
-            return scanner.getTokenOffset() + scanner.getTokenLength();
-        }
-        return -1;
-    }
-    return positions.map(getSelectionRange);
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Range, SelectionRange } from '../jsonLanguageTypes';
+import { createScanner } from 'jsonc-parser';
+export function getSelectionRanges(document, positions, doc) {
+    function getSelectionRange(position) {
+        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 {
+                    const cStart = node.offset + 1, cEnd = node.offset + node.length - 1;
+                    if (cStart < cEnd && offset >= cStart && offset <= cEnd) {
+                        result.push(newRange(cStart, cEnd));
+                    }
+                    result.push(newRange(node.offset, node.offset + node.length));
+                    break;
+                case 'number':
+                case 'boolean':
+                case 'null':
+                case 'property':
+                    result.push(newRange(node.offset, node.offset + node.length));
+                    break;
+            }
+            if (node.type === 'property' || node.parent && node.parent.type === 'array') {
+                const afterCommaOffset = getOffsetAfterNextToken(node.offset + node.length, 5 /* SyntaxKind.CommaToken */);
+                if (afterCommaOffset !== -1) {
+                    result.push(newRange(node.offset, afterCommaOffset));
+                }
+            }
+            node = node.parent;
+        }
+        let current = undefined;
+        for (let index = result.length - 1; index >= 0; index--) {
+            current = SelectionRange.create(result[index], current);
+        }
+        if (!current) {
+            current = SelectionRange.create(Range.create(position, position));
+        }
+        return current;
+    }
+    function newRange(start, end) {
+        return Range.create(document.positionAt(start), document.positionAt(end));
+    }
+    const scanner = createScanner(document.getText(), true);
+    function getOffsetAfterNextToken(offset, expectedToken) {
+        scanner.setPosition(offset);
+        let token = scanner.scan();
+        if (token === expectedToken) {
+            return scanner.getTokenOffset() + scanner.getTokenLength();
+        }
+        return -1;
+    }
+    return positions.map(getSelectionRange);
+}

package/lib/esm/services/jsonValidation.js

@@ -1,151 +1,151 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { ErrorCode, Diagnostic, DiagnosticSeverity, Range } from '../jsonLanguageTypes';
-import * as nls from 'vscode-nls';
-import { isBoolean } from '../utils/objects';
-const localize = nls.loadMessageBundle();
-export class JSONValidation {
-    constructor(jsonSchemaService, promiseConstructor) {
-        this.jsonSchemaService = jsonSchemaService;
-        this.promise = promiseConstructor;
-        this.validationEnabled = true;
-    }
-    configure(raw) {
-        if (raw) {
-            this.validationEnabled = raw.validate !== false;
-            this.commentSeverity = raw.allowComments ? undefined : DiagnosticSeverity.Error;
-        }
-    }
-    doValidation(textDocument, jsonDocument, documentSettings, schema) {
-        if (!this.validationEnabled) {
-            return this.promise.resolve([]);
-        }
-        const diagnostics = [];
-        const added = {};
-        const addProblem = (problem) => {
-            // remove duplicated messages
-            const signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
-            if (!added[signature]) {
-                added[signature] = true;
-                diagnostics.push(problem);
-            }
-        };
-        const getDiagnostics = (schema) => {
-            let trailingCommaSeverity = documentSettings?.trailingCommas ? toDiagnosticSeverity(documentSettings.trailingCommas) : DiagnosticSeverity.Error;
-            let commentSeverity = documentSettings?.comments ? toDiagnosticSeverity(documentSettings.comments) : this.commentSeverity;
-            let schemaValidation = documentSettings?.schemaValidation ? toDiagnosticSeverity(documentSettings.schemaValidation) : DiagnosticSeverity.Warning;
-            let schemaRequest = documentSettings?.schemaRequest ? toDiagnosticSeverity(documentSettings.schemaRequest) : DiagnosticSeverity.Warning;
-            if (schema) {
-                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 = Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
-                            addProblem(Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
-                        }
-                        else {
-                            const range = Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
-                            addProblem(Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
-                        }
-                    }
-                };
-                if (schema.errors.length) {
-                    addSchemaProblem(schema.errors[0], ErrorCode.SchemaResolveError);
-                }
-                else if (schemaValidation) {
-                    for (const warning of schema.warnings) {
-                        addSchemaProblem(warning, ErrorCode.SchemaUnsupportedFeature);
-                    }
-                    const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation);
-                    if (semanticErrors) {
-                        semanticErrors.forEach(addProblem);
-                    }
-                }
-                if (schemaAllowsComments(schema.schema)) {
-                    commentSeverity = undefined;
-                }
-                if (schemaAllowsTrailingCommas(schema.schema)) {
-                    trailingCommaSeverity = undefined;
-                }
-            }
-            for (const p of jsonDocument.syntaxErrors) {
-                if (p.code === ErrorCode.TrailingComma) {
-                    if (typeof trailingCommaSeverity !== 'number') {
-                        continue;
-                    }
-                    p.severity = trailingCommaSeverity;
-                }
-                addProblem(p);
-            }
-            if (typeof commentSeverity === 'number') {
-                const message = localize('InvalidCommentToken', 'Comments are not permitted in JSON.');
-                jsonDocument.comments.forEach(c => {
-                    addProblem(Diagnostic.create(c, message, commentSeverity, ErrorCode.CommentNotPermitted));
-                });
-            }
-            return diagnostics;
-        };
-        if (schema) {
-            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(schema => {
-            return getDiagnostics(schema);
-        });
-    }
-    getLanguageStatus(textDocument, jsonDocument) {
-        return { schemas: this.jsonSchemaService.getSchemaURIsForResource(textDocument.uri, jsonDocument) };
-    }
-}
-let idCounter = 0;
-function schemaAllowsComments(schemaRef) {
-    if (schemaRef && typeof schemaRef === 'object') {
-        if (isBoolean(schemaRef.allowComments)) {
-            return schemaRef.allowComments;
-        }
-        if (schemaRef.allOf) {
-            for (const schema of schemaRef.allOf) {
-                const allow = schemaAllowsComments(schema);
-                if (isBoolean(allow)) {
-                    return allow;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function schemaAllowsTrailingCommas(schemaRef) {
-    if (schemaRef && typeof schemaRef === 'object') {
-        if (isBoolean(schemaRef.allowTrailingCommas)) {
-            return schemaRef.allowTrailingCommas;
-        }
-        const deprSchemaRef = schemaRef;
-        if (isBoolean(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
-            return deprSchemaRef['allowsTrailingCommas'];
-        }
-        if (schemaRef.allOf) {
-            for (const schema of schemaRef.allOf) {
-                const allow = schemaAllowsTrailingCommas(schema);
-                if (isBoolean(allow)) {
-                    return allow;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function toDiagnosticSeverity(severityLevel) {
-    switch (severityLevel) {
-        case 'error': return DiagnosticSeverity.Error;
-        case 'warning': return DiagnosticSeverity.Warning;
-        case 'ignore': return undefined;
-    }
-    return undefined;
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { ErrorCode, Diagnostic, DiagnosticSeverity, Range } from '../jsonLanguageTypes';
+import * as nls from 'vscode-nls';
+import { isBoolean } from '../utils/objects';
+const localize = nls.loadMessageBundle();
+export class JSONValidation {
+    constructor(jsonSchemaService, promiseConstructor) {
+        this.jsonSchemaService = jsonSchemaService;
+        this.promise = promiseConstructor;
+        this.validationEnabled = true;
+    }
+    configure(raw) {
+        if (raw) {
+            this.validationEnabled = raw.validate !== false;
+            this.commentSeverity = raw.allowComments ? undefined : DiagnosticSeverity.Error;
+        }
+    }
+    doValidation(textDocument, jsonDocument, documentSettings, schema) {
+        if (!this.validationEnabled) {
+            return this.promise.resolve([]);
+        }
+        const diagnostics = [];
+        const added = {};
+        const addProblem = (problem) => {
+            // remove duplicated messages
+            const signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
+            if (!added[signature]) {
+                added[signature] = true;
+                diagnostics.push(problem);
+            }
+        };
+        const getDiagnostics = (schema) => {
+            let trailingCommaSeverity = documentSettings?.trailingCommas ? toDiagnosticSeverity(documentSettings.trailingCommas) : DiagnosticSeverity.Error;
+            let commentSeverity = documentSettings?.comments ? toDiagnosticSeverity(documentSettings.comments) : this.commentSeverity;
+            let schemaValidation = documentSettings?.schemaValidation ? toDiagnosticSeverity(documentSettings.schemaValidation) : DiagnosticSeverity.Warning;
+            let schemaRequest = documentSettings?.schemaRequest ? toDiagnosticSeverity(documentSettings.schemaRequest) : DiagnosticSeverity.Warning;
+            if (schema) {
+                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 = Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
+                            addProblem(Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
+                        }
+                        else {
+                            const range = Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
+                            addProblem(Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
+                        }
+                    }
+                };
+                if (schema.errors.length) {
+                    addSchemaProblem(schema.errors[0], ErrorCode.SchemaResolveError);
+                }
+                else if (schemaValidation) {
+                    for (const warning of schema.warnings) {
+                        addSchemaProblem(warning, ErrorCode.SchemaUnsupportedFeature);
+                    }
+                    const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation, documentSettings?.schemaDraft);
+                    if (semanticErrors) {
+                        semanticErrors.forEach(addProblem);
+                    }
+                }
+                if (schemaAllowsComments(schema.schema)) {
+                    commentSeverity = undefined;
+                }
+                if (schemaAllowsTrailingCommas(schema.schema)) {
+                    trailingCommaSeverity = undefined;
+                }
+            }
+            for (const p of jsonDocument.syntaxErrors) {
+                if (p.code === ErrorCode.TrailingComma) {
+                    if (typeof trailingCommaSeverity !== 'number') {
+                        continue;
+                    }
+                    p.severity = trailingCommaSeverity;
+                }
+                addProblem(p);
+            }
+            if (typeof commentSeverity === 'number') {
+                const message = localize('InvalidCommentToken', 'Comments are not permitted in JSON.');
+                jsonDocument.comments.forEach(c => {
+                    addProblem(Diagnostic.create(c, message, commentSeverity, ErrorCode.CommentNotPermitted));
+                });
+            }
+            return diagnostics;
+        };
+        if (schema) {
+            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(schema => {
+            return getDiagnostics(schema);
+        });
+    }
+    getLanguageStatus(textDocument, jsonDocument) {
+        return { schemas: this.jsonSchemaService.getSchemaURIsForResource(textDocument.uri, jsonDocument) };
+    }
+}
+let idCounter = 0;
+function schemaAllowsComments(schemaRef) {
+    if (schemaRef && typeof schemaRef === 'object') {
+        if (isBoolean(schemaRef.allowComments)) {
+            return schemaRef.allowComments;
+        }
+        if (schemaRef.allOf) {
+            for (const schema of schemaRef.allOf) {
+                const allow = schemaAllowsComments(schema);
+                if (isBoolean(allow)) {
+                    return allow;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function schemaAllowsTrailingCommas(schemaRef) {
+    if (schemaRef && typeof schemaRef === 'object') {
+        if (isBoolean(schemaRef.allowTrailingCommas)) {
+            return schemaRef.allowTrailingCommas;
+        }
+        const deprSchemaRef = schemaRef;
+        if (isBoolean(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
+            return deprSchemaRef['allowsTrailingCommas'];
+        }
+        if (schemaRef.allOf) {
+            for (const schema of schemaRef.allOf) {
+                const allow = schemaAllowsTrailingCommas(schema);
+                if (isBoolean(allow)) {
+                    return allow;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function toDiagnosticSeverity(severityLevel) {
+    switch (severityLevel) {
+        case 'error': return DiagnosticSeverity.Error;
+        case 'warning': return DiagnosticSeverity.Warning;
+        case 'ignore': return undefined;
+    }
+    return undefined;
+}

package/lib/esm/utils/colors.js

@@ -1,68 +1,68 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const Digit0 = 48;
-const Digit9 = 57;
-const A = 65;
-const a = 97;
-const f = 102;
-export function hexDigit(charCode) {
-    if (charCode < Digit0) {
-        return 0;
-    }
-    if (charCode <= Digit9) {
-        return charCode - Digit0;
-    }
-    if (charCode < a) {
-        charCode += (a - A);
-    }
-    if (charCode >= a && charCode <= f) {
-        return charCode - a + 10;
-    }
-    return 0;
-}
-export function colorFromHex(text) {
-    if (text[0] !== '#') {
-        return undefined;
-    }
-    switch (text.length) {
-        case 4:
-            return {
-                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
-                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
-                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
-                alpha: 1
-            };
-        case 5:
-            return {
-                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
-                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
-                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
-                alpha: (hexDigit(text.charCodeAt(4)) * 0x11) / 255.0,
-            };
-        case 7:
-            return {
-                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
-                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
-                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
-                alpha: 1
-            };
-        case 9:
-            return {
-                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
-                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
-                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
-                alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
-            };
-    }
-    return undefined;
-}
-export function colorFrom256RGB(red, green, blue, alpha = 1.0) {
-    return {
-        red: red / 255.0,
-        green: green / 255.0,
-        blue: blue / 255.0,
-        alpha
-    };
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const Digit0 = 48;
+const Digit9 = 57;
+const A = 65;
+const a = 97;
+const f = 102;
+export function hexDigit(charCode) {
+    if (charCode < Digit0) {
+        return 0;
+    }
+    if (charCode <= Digit9) {
+        return charCode - Digit0;
+    }
+    if (charCode < a) {
+        charCode += (a - A);
+    }
+    if (charCode >= a && charCode <= f) {
+        return charCode - a + 10;
+    }
+    return 0;
+}
+export function colorFromHex(text) {
+    if (text[0] !== '#') {
+        return undefined;
+    }
+    switch (text.length) {
+        case 4:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
+                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
+                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
+                alpha: 1
+            };
+        case 5:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
+                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
+                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
+                alpha: (hexDigit(text.charCodeAt(4)) * 0x11) / 255.0,
+            };
+        case 7:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
+                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
+                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
+                alpha: 1
+            };
+        case 9:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
+                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
+                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
+                alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
+            };
+    }
+    return undefined;
+}
+export function colorFrom256RGB(red, green, blue, alpha = 1.0) {
+    return {
+        red: red / 255.0,
+        green: green / 255.0,
+        blue: blue / 255.0,
+        alpha
+    };
+}