vscode-json-languageservice 5.0.0 → 5.1.0

package/lib/esm/services/jsonFolding.js

@@ -1,120 +1,120 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { createScanner } from 'jsonc-parser';
-import { FoldingRangeKind, Position } from '../jsonLanguageTypes';
-export function getFoldingRanges(document, context) {
-    const ranges = [];
-    const nestingLevels = [];
-    const stack = [];
-    let prevStart = -1;
-    const scanner = createScanner(document.getText(), false);
-    let token = scanner.scan();
-    function addRange(range) {
-        ranges.push(range);
-        nestingLevels.push(stack.length);
-    }
-    while (token !== 17 /* EOF */) {
-        switch (token) {
-            case 1 /* OpenBraceToken */:
-            case 3 /* OpenBracketToken */: {
-                const startLine = document.positionAt(scanner.getTokenOffset()).line;
-                const range = { startLine, endLine: startLine, kind: token === 1 /* OpenBraceToken */ ? 'object' : 'array' };
-                stack.push(range);
-                break;
-            }
-            case 2 /* CloseBraceToken */:
-            case 4 /* CloseBracketToken */: {
-                const kind = token === 2 /* CloseBraceToken */ ? 'object' : 'array';
-                if (stack.length > 0 && stack[stack.length - 1].kind === kind) {
-                    const range = stack.pop();
-                    const line = document.positionAt(scanner.getTokenOffset()).line;
-                    if (range && line > range.startLine + 1 && prevStart !== range.startLine) {
-                        range.endLine = line - 1;
-                        addRange(range);
-                        prevStart = range.startLine;
-                    }
-                }
-                break;
-            }
-            case 13 /* BlockCommentTrivia */: {
-                const startLine = document.positionAt(scanner.getTokenOffset()).line;
-                const endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
-                if (scanner.getTokenError() === 1 /* UnexpectedEndOfComment */ && startLine + 1 < document.lineCount) {
-                    scanner.setPosition(document.offsetAt(Position.create(startLine + 1, 0)));
-                }
-                else {
-                    if (startLine < endLine) {
-                        addRange({ startLine, endLine, kind: FoldingRangeKind.Comment });
-                        prevStart = startLine;
-                    }
-                }
-                break;
-            }
-            case 12 /* LineCommentTrivia */: {
-                const text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());
-                const m = text.match(/^\/\/\s*#(region\b)|(endregion\b)/);
-                if (m) {
-                    const line = document.positionAt(scanner.getTokenOffset()).line;
-                    if (m[1]) { // start pattern match
-                        const range = { startLine: line, endLine: line, kind: FoldingRangeKind.Region };
-                        stack.push(range);
-                    }
-                    else {
-                        let i = stack.length - 1;
-                        while (i >= 0 && stack[i].kind !== FoldingRangeKind.Region) {
-                            i--;
-                        }
-                        if (i >= 0) {
-                            const range = stack[i];
-                            stack.length = i;
-                            if (line > range.startLine && prevStart !== range.startLine) {
-                                range.endLine = line;
-                                addRange(range);
-                                prevStart = range.startLine;
-                            }
-                        }
-                    }
-                }
-                break;
-            }
-        }
-        token = scanner.scan();
-    }
-    const rangeLimit = context && context.rangeLimit;
-    if (typeof rangeLimit !== 'number' || ranges.length <= rangeLimit) {
-        return ranges;
-    }
-    if (context && context.onRangeLimitExceeded) {
-        context.onRangeLimitExceeded(document.uri);
-    }
-    const counts = [];
-    for (let level of nestingLevels) {
-        if (level < 30) {
-            counts[level] = (counts[level] || 0) + 1;
-        }
-    }
-    let entries = 0;
-    let maxLevel = 0;
-    for (let i = 0; i < counts.length; i++) {
-        const n = counts[i];
-        if (n) {
-            if (n + entries > rangeLimit) {
-                maxLevel = i;
-                break;
-            }
-            entries += n;
-        }
-    }
-    const result = [];
-    for (let i = 0; i < ranges.length; i++) {
-        const level = nestingLevels[i];
-        if (typeof level === 'number') {
-            if (level < maxLevel || (level === maxLevel && entries++ < rangeLimit)) {
-                result.push(ranges[i]);
-            }
-        }
-    }
-    return result;
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from 'jsonc-parser';
+import { FoldingRangeKind, Position } from '../jsonLanguageTypes';
+export function getFoldingRanges(document, context) {
+    const ranges = [];
+    const nestingLevels = [];
+    const stack = [];
+    let prevStart = -1;
+    const scanner = createScanner(document.getText(), false);
+    let token = scanner.scan();
+    function addRange(range) {
+        ranges.push(range);
+        nestingLevels.push(stack.length);
+    }
+    while (token !== 17 /* SyntaxKind.EOF */) {
+        switch (token) {
+            case 1 /* SyntaxKind.OpenBraceToken */:
+            case 3 /* SyntaxKind.OpenBracketToken */: {
+                const startLine = document.positionAt(scanner.getTokenOffset()).line;
+                const range = { startLine, endLine: startLine, kind: token === 1 /* SyntaxKind.OpenBraceToken */ ? 'object' : 'array' };
+                stack.push(range);
+                break;
+            }
+            case 2 /* SyntaxKind.CloseBraceToken */:
+            case 4 /* SyntaxKind.CloseBracketToken */: {
+                const kind = token === 2 /* SyntaxKind.CloseBraceToken */ ? 'object' : 'array';
+                if (stack.length > 0 && stack[stack.length - 1].kind === kind) {
+                    const range = stack.pop();
+                    const line = document.positionAt(scanner.getTokenOffset()).line;
+                    if (range && line > range.startLine + 1 && prevStart !== range.startLine) {
+                        range.endLine = line - 1;
+                        addRange(range);
+                        prevStart = range.startLine;
+                    }
+                }
+                break;
+            }
+            case 13 /* SyntaxKind.BlockCommentTrivia */: {
+                const startLine = document.positionAt(scanner.getTokenOffset()).line;
+                const endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
+                if (scanner.getTokenError() === 1 /* ScanError.UnexpectedEndOfComment */ && startLine + 1 < document.lineCount) {
+                    scanner.setPosition(document.offsetAt(Position.create(startLine + 1, 0)));
+                }
+                else {
+                    if (startLine < endLine) {
+                        addRange({ startLine, endLine, kind: FoldingRangeKind.Comment });
+                        prevStart = startLine;
+                    }
+                }
+                break;
+            }
+            case 12 /* SyntaxKind.LineCommentTrivia */: {
+                const text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());
+                const m = text.match(/^\/\/\s*#(region\b)|(endregion\b)/);
+                if (m) {
+                    const line = document.positionAt(scanner.getTokenOffset()).line;
+                    if (m[1]) { // start pattern match
+                        const range = { startLine: line, endLine: line, kind: FoldingRangeKind.Region };
+                        stack.push(range);
+                    }
+                    else {
+                        let i = stack.length - 1;
+                        while (i >= 0 && stack[i].kind !== FoldingRangeKind.Region) {
+                            i--;
+                        }
+                        if (i >= 0) {
+                            const range = stack[i];
+                            stack.length = i;
+                            if (line > range.startLine && prevStart !== range.startLine) {
+                                range.endLine = line;
+                                addRange(range);
+                                prevStart = range.startLine;
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        token = scanner.scan();
+    }
+    const rangeLimit = context && context.rangeLimit;
+    if (typeof rangeLimit !== 'number' || ranges.length <= rangeLimit) {
+        return ranges;
+    }
+    if (context && context.onRangeLimitExceeded) {
+        context.onRangeLimitExceeded(document.uri);
+    }
+    const counts = [];
+    for (let level of nestingLevels) {
+        if (level < 30) {
+            counts[level] = (counts[level] || 0) + 1;
+        }
+    }
+    let entries = 0;
+    let maxLevel = 0;
+    for (let i = 0; i < counts.length; i++) {
+        const n = counts[i];
+        if (n) {
+            if (n + entries > rangeLimit) {
+                maxLevel = i;
+                break;
+            }
+            entries += n;
+        }
+    }
+    const result = [];
+    for (let i = 0; i < ranges.length; i++) {
+        const level = nestingLevels[i];
+        if (typeof level === 'number') {
+            if (level < maxLevel || (level === maxLevel && entries++ < rangeLimit)) {
+                result.push(ranges[i]);
+            }
+        }
+    }
+    return result;
+}

package/lib/esm/services/jsonHover.js

@@ -1,109 +1,109 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import * as Parser from '../parser/jsonParser';
-import { Range } from '../jsonLanguageTypes';
-export class JSONHover {
-    constructor(schemaService, contributions = [], promiseConstructor) {
-        this.schemaService = schemaService;
-        this.contributions = contributions;
-        this.promise = promiseConstructor || Promise;
-    }
-    doHover(document, position, doc) {
-        const offset = document.offsetAt(position);
-        let node = doc.getNodeFromOffset(offset);
-        if (!node || (node.type === 'object' || node.type === 'array') && offset > node.offset + 1 && offset < node.offset + node.length - 1) {
-            return this.promise.resolve(null);
-        }
-        const hoverRangeNode = node;
-        // use the property description when hovering over an object key
-        if (node.type === 'string') {
-            const parent = node.parent;
-            if (parent && parent.type === 'property' && parent.keyNode === node) {
-                node = parent.valueNode;
-                if (!node) {
-                    return this.promise.resolve(null);
-                }
-            }
-        }
-        const hoverRange = Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
-        var createHover = (contents) => {
-            const result = {
-                contents: contents,
-                range: hoverRange
-            };
-            return result;
-        };
-        const location = Parser.getNodePath(node);
-        for (let i = this.contributions.length - 1; i >= 0; i--) {
-            const contribution = this.contributions[i];
-            const promise = contribution.getInfoContribution(document.uri, location);
-            if (promise) {
-                return promise.then(htmlContent => createHover(htmlContent));
-            }
-        }
-        return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
-            if (schema && node) {
-                const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
-                let title = undefined;
-                let markdownDescription = undefined;
-                let markdownEnumValueDescription = undefined, enumValue = undefined;
-                matchingSchemas.every((s) => {
-                    if (s.node === node && !s.inverted && s.schema) {
-                        title = title || s.schema.title;
-                        markdownDescription = markdownDescription || s.schema.markdownDescription || toMarkdown(s.schema.description);
-                        if (s.schema.enum) {
-                            const idx = s.schema.enum.indexOf(Parser.getNodeValue(node));
-                            if (s.schema.markdownEnumDescriptions) {
-                                markdownEnumValueDescription = s.schema.markdownEnumDescriptions[idx];
-                            }
-                            else if (s.schema.enumDescriptions) {
-                                markdownEnumValueDescription = toMarkdown(s.schema.enumDescriptions[idx]);
-                            }
-                            if (markdownEnumValueDescription) {
-                                enumValue = s.schema.enum[idx];
-                                if (typeof enumValue !== 'string') {
-                                    enumValue = JSON.stringify(enumValue);
-                                }
-                            }
-                        }
-                    }
-                    return true;
-                });
-                let result = '';
-                if (title) {
-                    result = toMarkdown(title);
-                }
-                if (markdownDescription) {
-                    if (result.length > 0) {
-                        result += "\n\n";
-                    }
-                    result += markdownDescription;
-                }
-                if (markdownEnumValueDescription) {
-                    if (result.length > 0) {
-                        result += "\n\n";
-                    }
-                    result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
-                }
-                return createHover([result]);
-            }
-            return null;
-        });
-    }
-}
-function toMarkdown(plain) {
-    if (plain) {
-        const res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
-        return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
-    }
-    return undefined;
-}
-function toMarkdownCodeBlock(content) {
-    // see https://daringfireball.net/projects/markdown/syntax#precode
-    if (content.indexOf('`') !== -1) {
-        return '`` ' + content + ' ``';
-    }
-    return content;
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as Parser from '../parser/jsonParser';
+import { Range } from '../jsonLanguageTypes';
+export class JSONHover {
+    constructor(schemaService, contributions = [], promiseConstructor) {
+        this.schemaService = schemaService;
+        this.contributions = contributions;
+        this.promise = promiseConstructor || Promise;
+    }
+    doHover(document, position, doc) {
+        const offset = document.offsetAt(position);
+        let node = doc.getNodeFromOffset(offset);
+        if (!node || (node.type === 'object' || node.type === 'array') && offset > node.offset + 1 && offset < node.offset + node.length - 1) {
+            return this.promise.resolve(null);
+        }
+        const hoverRangeNode = node;
+        // use the property description when hovering over an object key
+        if (node.type === 'string') {
+            const parent = node.parent;
+            if (parent && parent.type === 'property' && parent.keyNode === node) {
+                node = parent.valueNode;
+                if (!node) {
+                    return this.promise.resolve(null);
+                }
+            }
+        }
+        const hoverRange = Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
+        var createHover = (contents) => {
+            const result = {
+                contents: contents,
+                range: hoverRange
+            };
+            return result;
+        };
+        const location = Parser.getNodePath(node);
+        for (let i = this.contributions.length - 1; i >= 0; i--) {
+            const contribution = this.contributions[i];
+            const promise = contribution.getInfoContribution(document.uri, location);
+            if (promise) {
+                return promise.then(htmlContent => createHover(htmlContent));
+            }
+        }
+        return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
+            if (schema && node) {
+                const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
+                let title = undefined;
+                let markdownDescription = undefined;
+                let markdownEnumValueDescription = undefined, enumValue = undefined;
+                matchingSchemas.every((s) => {
+                    if (s.node === node && !s.inverted && s.schema) {
+                        title = title || s.schema.title;
+                        markdownDescription = markdownDescription || s.schema.markdownDescription || toMarkdown(s.schema.description);
+                        if (s.schema.enum) {
+                            const idx = s.schema.enum.indexOf(Parser.getNodeValue(node));
+                            if (s.schema.markdownEnumDescriptions) {
+                                markdownEnumValueDescription = s.schema.markdownEnumDescriptions[idx];
+                            }
+                            else if (s.schema.enumDescriptions) {
+                                markdownEnumValueDescription = toMarkdown(s.schema.enumDescriptions[idx]);
+                            }
+                            if (markdownEnumValueDescription) {
+                                enumValue = s.schema.enum[idx];
+                                if (typeof enumValue !== 'string') {
+                                    enumValue = JSON.stringify(enumValue);
+                                }
+                            }
+                        }
+                    }
+                    return true;
+                });
+                let result = '';
+                if (title) {
+                    result = toMarkdown(title);
+                }
+                if (markdownDescription) {
+                    if (result.length > 0) {
+                        result += "\n\n";
+                    }
+                    result += markdownDescription;
+                }
+                if (markdownEnumValueDescription) {
+                    if (result.length > 0) {
+                        result += "\n\n";
+                    }
+                    result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
+                }
+                return createHover([result]);
+            }
+            return null;
+        });
+    }
+}
+function toMarkdown(plain) {
+    if (plain) {
+        const res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
+        return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
+    }
+    return undefined;
+}
+function toMarkdownCodeBlock(content) {
+    // see https://daringfireball.net/projects/markdown/syntax#precode
+    if (content.indexOf('`') !== -1) {
+        return '`` ' + content + ' ``';
+    }
+    return content;
+}

package/lib/esm/services/jsonLinks.js

@@ -1,72 +1,72 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Range } from '../jsonLanguageTypes';
-export function findLinks(document, doc) {
-    const links = [];
-    doc.visit(node => {
-        if (node.type === "property" && node.keyNode.value === "$ref" && node.valueNode?.type === 'string') {
-            const path = node.valueNode.value;
-            const targetNode = findTargetNode(doc, path);
-            if (targetNode) {
-                const targetPos = document.positionAt(targetNode.offset);
-                links.push({
-                    target: `${document.uri}#${targetPos.line + 1},${targetPos.character + 1}`,
-                    range: createRange(document, node.valueNode)
-                });
-            }
-        }
-        return true;
-    });
-    return Promise.resolve(links);
-}
-function createRange(document, node) {
-    return Range.create(document.positionAt(node.offset + 1), document.positionAt(node.offset + node.length - 1));
-}
-function findTargetNode(doc, path) {
-    const tokens = parseJSONPointer(path);
-    if (!tokens) {
-        return null;
-    }
-    return findNode(tokens, doc.root);
-}
-function findNode(pointer, node) {
-    if (!node) {
-        return null;
-    }
-    if (pointer.length === 0) {
-        return node;
-    }
-    const token = pointer.shift();
-    if (node && node.type === 'object') {
-        const propertyNode = node.properties.find((propertyNode) => propertyNode.keyNode.value === token);
-        if (!propertyNode) {
-            return null;
-        }
-        return findNode(pointer, propertyNode.valueNode);
-    }
-    else if (node && node.type === 'array') {
-        if (token.match(/^(0|[1-9][0-9]*)$/)) {
-            const index = Number.parseInt(token);
-            const arrayItem = node.items[index];
-            if (!arrayItem) {
-                return null;
-            }
-            return findNode(pointer, arrayItem);
-        }
-    }
-    return null;
-}
-function parseJSONPointer(path) {
-    if (path === "#") {
-        return [];
-    }
-    if (path[0] !== '#' || path[1] !== '/') {
-        return null;
-    }
-    return path.substring(2).split(/\//).map(unescape);
-}
-function unescape(str) {
-    return str.replace(/~1/g, '/').replace(/~0/g, '~');
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Range } from '../jsonLanguageTypes';
+export function findLinks(document, doc) {
+    const links = [];
+    doc.visit(node => {
+        if (node.type === "property" && node.keyNode.value === "$ref" && node.valueNode?.type === 'string') {
+            const path = node.valueNode.value;
+            const targetNode = findTargetNode(doc, path);
+            if (targetNode) {
+                const targetPos = document.positionAt(targetNode.offset);
+                links.push({
+                    target: `${document.uri}#${targetPos.line + 1},${targetPos.character + 1}`,
+                    range: createRange(document, node.valueNode)
+                });
+            }
+        }
+        return true;
+    });
+    return Promise.resolve(links);
+}
+function createRange(document, node) {
+    return Range.create(document.positionAt(node.offset + 1), document.positionAt(node.offset + node.length - 1));
+}
+function findTargetNode(doc, path) {
+    const tokens = parseJSONPointer(path);
+    if (!tokens) {
+        return null;
+    }
+    return findNode(tokens, doc.root);
+}
+function findNode(pointer, node) {
+    if (!node) {
+        return null;
+    }
+    if (pointer.length === 0) {
+        return node;
+    }
+    const token = pointer.shift();
+    if (node && node.type === 'object') {
+        const propertyNode = node.properties.find((propertyNode) => propertyNode.keyNode.value === token);
+        if (!propertyNode) {
+            return null;
+        }
+        return findNode(pointer, propertyNode.valueNode);
+    }
+    else if (node && node.type === 'array') {
+        if (token.match(/^(0|[1-9][0-9]*)$/)) {
+            const index = Number.parseInt(token);
+            const arrayItem = node.items[index];
+            if (!arrayItem) {
+                return null;
+            }
+            return findNode(pointer, arrayItem);
+        }
+    }
+    return null;
+}
+function parseJSONPointer(path) {
+    if (path === "#") {
+        return [];
+    }
+    if (path[0] !== '#' || path[1] !== '/') {
+        return null;
+    }
+    return path.substring(2).split(/\//).map(unescape);
+}
+function unescape(str) {
+    return str.replace(/~1/g, '/').replace(/~0/g, '~');
+}