vscode-json-languageservice 5.7.2 → 6.0.0-next.2

package/lib/umd/services/jsonDocumentSymbols.js

@@ -1,285 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../parser/jsonParser", "../utils/strings", "../utils/colors", "@vscode/l10n", "../jsonLanguageTypes"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.JSONDocumentSymbols = void 0;
-    const Parser = require("../parser/jsonParser");
-    const Strings = require("../utils/strings");
-    const colors_1 = require("../utils/colors");
-    const l10n = require("@vscode/l10n");
-    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    class JSONDocumentSymbols {
-        constructor(schemaService) {
-            this.schemaService = schemaService;
-        }
-        findDocumentSymbols(document, doc, context = { resultLimit: Number.MAX_VALUE }) {
-            const root = doc.root;
-            if (!root) {
-                return [];
-            }
-            let limit = context.resultLimit || Number.MAX_VALUE;
-            // special handling for key bindings
-            const resourceString = document.uri;
-            if ((resourceString === 'vscode://defaultsettings/keybindings.json') || Strings.endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {
-                if (root.type === 'array') {
-                    const result = [];
-                    for (const item of root.items) {
-                        if (item.type === 'object') {
-                            for (const property of item.properties) {
-                                if (property.keyNode.value === 'key' && property.valueNode) {
-                                    const location = jsonLanguageTypes_1.Location.create(document.uri, getRange(document, item));
-                                    result.push({ name: getName(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, location: location });
-                                    limit--;
-                                    if (limit <= 0) {
-                                        if (context && context.onResultLimitExceeded) {
-                                            context.onResultLimitExceeded(resourceString);
-                                        }
-                                        return result;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    return result;
-                }
-            }
-            const toVisit = [
-                { node: root, containerName: '' }
-            ];
-            let nextToVisit = 0;
-            let limitExceeded = false;
-            const result = [];
-            const collectOutlineEntries = (node, containerName) => {
-                if (node.type === 'array') {
-                    node.items.forEach(node => {
-                        if (node) {
-                            toVisit.push({ node, containerName });
-                        }
-                    });
-                }
-                else if (node.type === 'object') {
-                    node.properties.forEach((property) => {
-                        const valueNode = property.valueNode;
-                        if (valueNode) {
-                            if (limit > 0) {
-                                limit--;
-                                const location = jsonLanguageTypes_1.Location.create(document.uri, getRange(document, property));
-                                const childContainerName = containerName ? containerName + '.' + property.keyNode.value : property.keyNode.value;
-                                result.push({ name: this.getKeyLabel(property), kind: this.getSymbolKind(valueNode.type), location: location, containerName: containerName });
-                                toVisit.push({ node: valueNode, containerName: childContainerName });
-                            }
-                            else {
-                                limitExceeded = true;
-                            }
-                        }
-                    });
-                }
-            };
-            // breath first traversal
-            while (nextToVisit < toVisit.length) {
-                const next = toVisit[nextToVisit++];
-                collectOutlineEntries(next.node, next.containerName);
-            }
-            if (limitExceeded && context && context.onResultLimitExceeded) {
-                context.onResultLimitExceeded(resourceString);
-            }
-            return result;
-        }
-        findDocumentSymbols2(document, doc, context = { resultLimit: Number.MAX_VALUE }) {
-            const root = doc.root;
-            if (!root) {
-                return [];
-            }
-            let limit = context.resultLimit || Number.MAX_VALUE;
-            // special handling for key bindings
-            const resourceString = document.uri;
-            if ((resourceString === 'vscode://defaultsettings/keybindings.json') || Strings.endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {
-                if (root.type === 'array') {
-                    const result = [];
-                    for (const item of root.items) {
-                        if (item.type === 'object') {
-                            for (const property of item.properties) {
-                                if (property.keyNode.value === 'key' && property.valueNode) {
-                                    const range = getRange(document, item);
-                                    const selectionRange = getRange(document, property.keyNode);
-                                    result.push({ name: getName(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, range, selectionRange });
-                                    limit--;
-                                    if (limit <= 0) {
-                                        if (context && context.onResultLimitExceeded) {
-                                            context.onResultLimitExceeded(resourceString);
-                                        }
-                                        return result;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    return result;
-                }
-            }
-            const result = [];
-            const toVisit = [
-                { node: root, result }
-            ];
-            let nextToVisit = 0;
-            let limitExceeded = false;
-            const collectOutlineEntries = (node, result) => {
-                if (node.type === 'array') {
-                    node.items.forEach((node, index) => {
-                        if (node) {
-                            if (limit > 0) {
-                                limit--;
-                                const range = getRange(document, node);
-                                const selectionRange = range;
-                                const name = String(index);
-                                const symbol = { name, kind: this.getSymbolKind(node.type), range, selectionRange, children: [] };
-                                result.push(symbol);
-                                toVisit.push({ result: symbol.children, node });
-                            }
-                            else {
-                                limitExceeded = true;
-                            }
-                        }
-                    });
-                }
-                else if (node.type === 'object') {
-                    node.properties.forEach((property) => {
-                        const valueNode = property.valueNode;
-                        if (valueNode) {
-                            if (limit > 0) {
-                                limit--;
-                                const range = getRange(document, property);
-                                const selectionRange = getRange(document, property.keyNode);
-                                const children = [];
-                                const symbol = { name: this.getKeyLabel(property), kind: this.getSymbolKind(valueNode.type), range, selectionRange, children, detail: this.getDetail(valueNode) };
-                                result.push(symbol);
-                                toVisit.push({ result: children, node: valueNode });
-                            }
-                            else {
-                                limitExceeded = true;
-                            }
-                        }
-                    });
-                }
-            };
-            // breath first traversal
-            while (nextToVisit < toVisit.length) {
-                const next = toVisit[nextToVisit++];
-                collectOutlineEntries(next.node, next.result);
-            }
-            if (limitExceeded && context && context.onResultLimitExceeded) {
-                context.onResultLimitExceeded(resourceString);
-            }
-            return result;
-        }
-        getSymbolKind(nodeType) {
-            switch (nodeType) {
-                case 'object':
-                    return jsonLanguageTypes_1.SymbolKind.Module;
-                case 'string':
-                    return jsonLanguageTypes_1.SymbolKind.String;
-                case 'number':
-                    return jsonLanguageTypes_1.SymbolKind.Number;
-                case 'array':
-                    return jsonLanguageTypes_1.SymbolKind.Array;
-                case 'boolean':
-                    return jsonLanguageTypes_1.SymbolKind.Boolean;
-                default: // 'null'
-                    return jsonLanguageTypes_1.SymbolKind.Variable;
-            }
-        }
-        getKeyLabel(property) {
-            let name = property.keyNode.value;
-            if (name) {
-                name = name.replace(/[\n]/g, '↵');
-            }
-            if (name && name.trim()) {
-                return name;
-            }
-            return `"${name}"`;
-        }
-        getDetail(node) {
-            if (!node) {
-                return undefined;
-            }
-            if (node.type === 'boolean' || node.type === 'number' || node.type === 'null' || node.type === 'string') {
-                return String(node.value);
-            }
-            else {
-                if (node.type === 'array') {
-                    return node.children.length ? undefined : '[]';
-                }
-                else if (node.type === 'object') {
-                    return node.children.length ? undefined : '{}';
-                }
-            }
-            return undefined;
-        }
-        findDocumentColors(document, doc, context) {
-            return this.schemaService.getSchemaForResource(document.uri, doc).then(schema => {
-                const result = [];
-                if (schema) {
-                    let limit = context && typeof context.resultLimit === 'number' ? context.resultLimit : Number.MAX_VALUE;
-                    const matchingSchemas = doc.getMatchingSchemas(schema.schema);
-                    const visitedNode = {};
-                    for (const s of matchingSchemas) {
-                        if (!s.inverted && s.schema && (s.schema.format === 'color' || s.schema.format === 'color-hex') && s.node && s.node.type === 'string') {
-                            const nodeId = String(s.node.offset);
-                            if (!visitedNode[nodeId]) {
-                                const color = (0, colors_1.colorFromHex)(Parser.getNodeValue(s.node));
-                                if (color) {
-                                    const range = getRange(document, s.node);
-                                    result.push({ color, range });
-                                }
-                                visitedNode[nodeId] = true;
-                                limit--;
-                                if (limit <= 0) {
-                                    if (context && context.onResultLimitExceeded) {
-                                        context.onResultLimitExceeded(document.uri);
-                                    }
-                                    return result;
-                                }
-                            }
-                        }
-                    }
-                }
-                return result;
-            });
-        }
-        getColorPresentations(document, doc, color, range) {
-            const result = [];
-            const red256 = Math.round(color.red * 255), green256 = Math.round(color.green * 255), blue256 = Math.round(color.blue * 255);
-            function toTwoDigitHex(n) {
-                const r = n.toString(16);
-                return r.length !== 2 ? '0' + r : r;
-            }
-            let label;
-            if (color.alpha === 1) {
-                label = `#${toTwoDigitHex(red256)}${toTwoDigitHex(green256)}${toTwoDigitHex(blue256)}`;
-            }
-            else {
-                label = `#${toTwoDigitHex(red256)}${toTwoDigitHex(green256)}${toTwoDigitHex(blue256)}${toTwoDigitHex(Math.round(color.alpha * 255))}`;
-            }
-            result.push({ label: label, textEdit: jsonLanguageTypes_1.TextEdit.replace(range, JSON.stringify(label)) });
-            return result;
-        }
-    }
-    exports.JSONDocumentSymbols = JSONDocumentSymbols;
-    function getRange(document, node) {
-        return jsonLanguageTypes_1.Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
-    }
-    function getName(node) {
-        return Parser.getNodeValue(node) || l10n.t('<empty>');
-    }
-});

package/lib/umd/services/jsonFolding.js

@@ -1,133 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "jsonc-parser", "../jsonLanguageTypes"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getFoldingRanges = getFoldingRanges;
-    const jsonc_parser_1 = require("jsonc-parser");
-    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    function getFoldingRanges(document, context) {
-        const ranges = [];
-        const nestingLevels = [];
-        const stack = [];
-        let prevStart = -1;
-        const scanner = (0, jsonc_parser_1.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(jsonLanguageTypes_1.Position.create(startLine + 1, 0)));
-                    }
-                    else {
-                        if (startLine < endLine) {
-                            addRange({ startLine, endLine, kind: jsonLanguageTypes_1.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: jsonLanguageTypes_1.FoldingRangeKind.Region };
-                            stack.push(range);
-                        }
-                        else {
-                            let i = stack.length - 1;
-                            while (i >= 0 && stack[i].kind !== jsonLanguageTypes_1.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/umd/services/jsonHover.js

@@ -1,125 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../parser/jsonParser", "../jsonLanguageTypes"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.JSONHover = void 0;
-    const Parser = require("../parser/jsonParser");
-    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    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 = jsonLanguageTypes_1.Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
-            const 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) {
-                    return null;
-                }
-                let title = undefined;
-                let markdownDescription = undefined;
-                let markdownEnumValueDescription = undefined, enumValue = undefined;
-                const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset).filter((s) => s.node === node && !s.inverted).map((s) => s.schema);
-                for (const schema of matchingSchemas) {
-                    title = title || schema.title;
-                    markdownDescription = markdownDescription || schema.markdownDescription || toMarkdown(schema.description);
-                    if (schema.enum) {
-                        const idx = schema.enum.indexOf(Parser.getNodeValue(node));
-                        if (schema.markdownEnumDescriptions) {
-                            markdownEnumValueDescription = schema.markdownEnumDescriptions[idx];
-                        }
-                        else if (schema.enumDescriptions) {
-                            markdownEnumValueDescription = toMarkdown(schema.enumDescriptions[idx]);
-                        }
-                        if (markdownEnumValueDescription) {
-                            enumValue = schema.enum[idx];
-                            if (typeof enumValue !== 'string') {
-                                enumValue = JSON.stringify(enumValue);
-                            }
-                        }
-                    }
-                }
-                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]);
-            });
-        }
-    }
-    exports.JSONHover = JSONHover;
-    function toMarkdown(plain) {
-        if (plain) {
-            return plain
-                .trim()
-                .replace(/[\\`*_{}[\]()<>#+\-.!]/g, '\\$&') // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
-                .replace(/(^ +)/mg, (_match, g1) => '&nbsp;'.repeat(g1.length)) // escape leading spaces on each line
-                .replace(/( {2,})/g, (_match, g1) => ' ' + '&nbsp;'.repeat(g1.length - 1)) // escape consecutive spaces
-                .replace(/(\t+)/g, (_match, g1) => '&nbsp;'.repeat(g1.length * 4)) // escape tabs
-                .replace(/\n/g, '\\\n'); // escape new lines
-        }
-        return undefined;
-    }
-    function toMarkdownCodeBlock(content) {
-        // see https://daringfireball.net/projects/markdown/syntax#precode
-        if (content.indexOf('`') !== -1) {
-            return '`` ' + content + ' ``';
-        }
-        return content;
-    }
-});

package/lib/umd/services/jsonLinks.js

@@ -1,85 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../jsonLanguageTypes"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.findLinks = findLinks;
-    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    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 jsonLanguageTypes_1.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, '~');
-    }
-});