volar-service-typescript 0.0.0

package/out/utils/previewer.js

@@ -0,0 +1,182 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMarkdownDocumentation = exports.markdownDocumentation = exports.tagsMarkdownPreview = exports.plainWithLinks = void 0;
+function replaceLinks(text) {
+    return text
+        // Http(s) links
+        .replace(/\{@(link|linkplain|linkcode) (https?:\/\/[^ |}]+?)(?:[| ]([^{}\n]+?))?\}/gi, (_, tag, link, text) => {
+        switch (tag) {
+            case 'linkcode':
+                return `[\`${text ? text.trim() : link}\`](${link})`;
+            default:
+                return `[${text ? text.trim() : link}](${link})`;
+        }
+    });
+}
+function processInlineTags(text) {
+    return replaceLinks(text);
+}
+function getTagBodyText(tag, filePathConverter, ctx) {
+    if (!tag.text) {
+        return undefined;
+    }
+    // Convert to markdown code block if it is not already one
+    function makeCodeblock(text) {
+        if (text.match(/^\s*[~`]{3}/g)) {
+            return text;
+        }
+        return '```\n' + text + '\n```';
+    }
+    const text = convertLinkTags(tag.text, filePathConverter, ctx);
+    switch (tag.name) {
+        case 'example':
+            // check for caption tags, fix for #79704
+            const captionTagMatches = text.match(/<caption>(.*?)<\/caption>\s*(\r\n|\n)/);
+            if (captionTagMatches && captionTagMatches.index === 0) {
+                return captionTagMatches[1] + '\n\n' + makeCodeblock(text.slice(captionTagMatches[0].length));
+            }
+            else {
+                return makeCodeblock(text);
+            }
+        case 'author':
+            // fix obfuscated email address, #80898
+            const emailMatch = text.match(/(.+)\s<([-.\w]+@[-.\w]+)>/);
+            if (emailMatch === null) {
+                return text;
+            }
+            else {
+                return `${emailMatch[1]} ${emailMatch[2]}`;
+            }
+        case 'default':
+            return makeCodeblock(text);
+    }
+    return processInlineTags(text);
+}
+function getTagDocumentation(tag, filePathConverter, ctx) {
+    switch (tag.name) {
+        case 'augments':
+        case 'extends':
+        case 'param':
+        case 'template':
+            const body = (convertLinkTags(tag.text, filePathConverter, ctx)).split(/^(\S+)\s*-?\s*/);
+            if (body?.length === 3) {
+                const param = body[1];
+                const doc = body[2];
+                const label = `*@${tag.name}* \`${param}\``;
+                if (!doc) {
+                    return label;
+                }
+                return label + (doc.match(/\r\n|\n/g) ? '  \n' + processInlineTags(doc) : ` — ${processInlineTags(doc)}`);
+            }
+    }
+    // Generic tag
+    const label = `*@${tag.name}*`;
+    const text = getTagBodyText(tag, filePathConverter, ctx);
+    if (!text) {
+        return label;
+    }
+    return label + (text.match(/\r\n|\n/g) ? '  \n' + text : ` — ${text}`);
+}
+function plainWithLinks(parts, filePathConverter, ctx) {
+    return processInlineTags(convertLinkTags(parts, filePathConverter, ctx));
+}
+exports.plainWithLinks = plainWithLinks;
+/**
+ * Convert `@link` inline tags to markdown links
+ */
+function convertLinkTags(parts, filePathConverter, ctx) {
+    if (!parts) {
+        return '';
+    }
+    if (typeof parts === 'string') {
+        return parts;
+    }
+    const out = [];
+    let currentLink;
+    for (const part of parts) {
+        switch (part.kind) {
+            case 'link':
+                if (currentLink) {
+                    const text = currentLink.text ?? currentLink.name;
+                    let target = currentLink.target;
+                    if (typeof currentLink.target === 'object' && 'fileName' in currentLink.target) {
+                        const _target = currentLink.target;
+                        const fileDoc = ctx.getTextDocument(ctx.env.uriToFileName(_target.fileName));
+                        if (fileDoc) {
+                            const start = fileDoc.positionAt(_target.textSpan.start);
+                            const end = fileDoc.positionAt(_target.textSpan.start + _target.textSpan.length);
+                            target = {
+                                file: _target.fileName,
+                                start: {
+                                    line: start.line + 1,
+                                    offset: start.character + 1,
+                                },
+                                end: {
+                                    line: end.line + 1,
+                                    offset: end.character + 1,
+                                },
+                            };
+                        }
+                        else {
+                            target = undefined;
+                        }
+                    }
+                    if (target) {
+                        const link = filePathConverter.toResource(target.file) + '#' + `L${target.start.line},${target.start.offset}`;
+                        out.push(`[${text}](${link})`);
+                    }
+                    else {
+                        if (text) {
+                            out.push(text);
+                        }
+                    }
+                    currentLink = undefined;
+                }
+                else {
+                    currentLink = {};
+                }
+                break;
+            case 'linkName':
+                if (currentLink) {
+                    currentLink.name = part.text;
+                    currentLink.target = part.target;
+                }
+                break;
+            case 'linkText':
+                if (currentLink) {
+                    currentLink.text = part.text;
+                }
+                break;
+            default:
+                out.push(part.text);
+                break;
+        }
+    }
+    return processInlineTags(out.join(''));
+}
+function tagsMarkdownPreview(tags, filePathConverter, ctx) {
+    return tags.map(tag => getTagDocumentation(tag, filePathConverter, ctx)).join('  \n\n');
+}
+exports.tagsMarkdownPreview = tagsMarkdownPreview;
+function markdownDocumentation(documentation, tags, filePathConverter, ctx) {
+    return addMarkdownDocumentation('', documentation, tags, filePathConverter, ctx);
+}
+exports.markdownDocumentation = markdownDocumentation;
+function addMarkdownDocumentation(out, documentation, tags, converter, ctx) {
+    if (documentation) {
+        out += plainWithLinks(documentation, converter, ctx);
+    }
+    if (tags) {
+        const tagsPreview = tagsMarkdownPreview(tags, converter, ctx);
+        if (tagsPreview) {
+            out += '\n\n' + tagsPreview;
+        }
+    }
+    return out;
+}
+exports.addMarkdownDocumentation = addMarkdownDocumentation;
+//# sourceMappingURL=previewer.js.map

package/out/utils/snippetForFunctionCall.d.ts

@@ -0,0 +1,8 @@
+import type * as Proto from '../protocol';
+export declare function snippetForFunctionCall(item: {
+    insertText?: string;
+    label: string;
+}, displayParts: ReadonlyArray<Proto.SymbolDisplayPart>): {
+    snippet: string;
+    parameterCount: number;
+};

package/out/utils/snippetForFunctionCall.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snippetForFunctionCall = void 0;
+const PConst = __importStar(require("../protocol.const"));
+function snippetForFunctionCall(item, displayParts) {
+    if (item.insertText && typeof item.insertText !== 'string') {
+        return { snippet: item.insertText, parameterCount: 0 };
+    }
+    let _tabstop = 1;
+    const parameterListParts = getParameterListParts(displayParts);
+    let snippet = '';
+    snippet += `${item.insertText || item.label}(`;
+    snippet = appendJoinedPlaceholders(snippet, parameterListParts.parts, ', ');
+    if (parameterListParts.hasOptionalParameters) {
+        snippet += '$' + _tabstop++;
+    }
+    snippet += ')';
+    snippet += '$' + _tabstop++;
+    return { snippet, parameterCount: parameterListParts.parts.length + (parameterListParts.hasOptionalParameters ? 1 : 0) };
+    function appendJoinedPlaceholders(snippet, parts, joiner) {
+        for (let i = 0; i < parts.length; ++i) {
+            const paramterPart = parts[i];
+            snippet += '${' + _tabstop++ + ':' + paramterPart.text + '}';
+            if (i !== parts.length - 1) {
+                snippet += joiner;
+            }
+        }
+        return snippet;
+    }
+}
+exports.snippetForFunctionCall = snippetForFunctionCall;
+function getParameterListParts(displayParts) {
+    const parts = [];
+    let isInMethod = false;
+    let hasOptionalParameters = false;
+    let parenCount = 0;
+    let braceCount = 0;
+    outer: for (let i = 0; i < displayParts.length; ++i) {
+        const part = displayParts[i];
+        switch (part.kind) {
+            case PConst.DisplayPartKind.methodName:
+            case PConst.DisplayPartKind.functionName:
+            case PConst.DisplayPartKind.text:
+            case PConst.DisplayPartKind.propertyName:
+                if (parenCount === 0 && braceCount === 0) {
+                    isInMethod = true;
+                }
+                break;
+            case PConst.DisplayPartKind.parameterName:
+                if (parenCount === 1 && braceCount === 0 && isInMethod) {
+                    // Only take top level paren names
+                    const next = displayParts[i + 1];
+                    // Skip optional parameters
+                    const nameIsFollowedByOptionalIndicator = next && next.text === '?';
+                    // Skip this parameter
+                    const nameIsThis = part.text === 'this';
+                    if (!nameIsFollowedByOptionalIndicator && !nameIsThis) {
+                        parts.push(part);
+                    }
+                    hasOptionalParameters = hasOptionalParameters || nameIsFollowedByOptionalIndicator;
+                }
+                break;
+            case PConst.DisplayPartKind.punctuation:
+                if (part.text === '(') {
+                    ++parenCount;
+                }
+                else if (part.text === ')') {
+                    --parenCount;
+                    if (parenCount <= 0 && isInMethod) {
+                        break outer;
+                    }
+                }
+                else if (part.text === '...' && parenCount === 1) {
+                    // Found rest parmeter. Do not fill in any further arguments
+                    hasOptionalParameters = true;
+                    break outer;
+                }
+                else if (part.text === '{') {
+                    ++braceCount;
+                }
+                else if (part.text === '}') {
+                    --braceCount;
+                }
+                break;
+        }
+    }
+    return { hasOptionalParameters, parts };
+}
+//# sourceMappingURL=snippetForFunctionCall.js.map

package/out/utils/transforms.d.ts

@@ -0,0 +1,10 @@
+import { SharedContext } from '../types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import * as vscode from 'vscode-languageserver-protocol';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function entriesToLocations(entries: {
+    fileName: string;
+    textSpan: ts.TextSpan;
+}[], ctx: SharedContext): vscode.Location[];
+export declare function entriesToLocationLinks<T extends ts.DocumentSpan>(entries: T[], ctx: SharedContext): vscode.LocationLink[];
+export declare function boundSpanToLocationLinks(info: ts.DefinitionInfoAndBoundSpan, originalDoc: TextDocument, ctx: SharedContext): vscode.LocationLink[];

package/out/utils/transforms.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boundSpanToLocationLinks = exports.entriesToLocationLinks = exports.entriesToLocations = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+function entriesToLocations(entries, ctx) {
+    const locations = [];
+    for (const entry of entries) {
+        const entryUri = ctx.env.fileNameToUri(entry.fileName);
+        const doc = ctx.getTextDocument(entryUri);
+        if (!doc)
+            continue;
+        const range = vscode.Range.create(doc.positionAt(entry.textSpan.start), doc.positionAt(entry.textSpan.start + entry.textSpan.length));
+        const location = vscode.Location.create(entryUri, range);
+        locations.push(location);
+    }
+    return locations;
+}
+exports.entriesToLocations = entriesToLocations;
+function entriesToLocationLinks(entries, ctx) {
+    const locations = [];
+    for (const entry of entries) {
+        const entryUri = ctx.env.fileNameToUri(entry.fileName);
+        const doc = ctx.getTextDocument(entryUri);
+        if (!doc)
+            continue;
+        const targetSelectionRange = vscode.Range.create(doc.positionAt(entry.textSpan.start), doc.positionAt(entry.textSpan.start + entry.textSpan.length));
+        const targetRange = entry.contextSpan ? vscode.Range.create(doc.positionAt(entry.contextSpan.start), doc.positionAt(entry.contextSpan.start + entry.contextSpan.length)) : targetSelectionRange;
+        const originSelectionRange = entry.originalTextSpan ? vscode.Range.create(doc.positionAt(entry.originalTextSpan.start), doc.positionAt(entry.originalTextSpan.start + entry.originalTextSpan.length)) : undefined;
+        const location = vscode.LocationLink.create(entryUri, targetRange, targetSelectionRange, originSelectionRange);
+        locations.push(location);
+    }
+    return locations;
+}
+exports.entriesToLocationLinks = entriesToLocationLinks;
+function boundSpanToLocationLinks(info, originalDoc, ctx) {
+    const locations = [];
+    if (!info.definitions)
+        return locations;
+    const originSelectionRange = vscode.Range.create(originalDoc.positionAt(info.textSpan.start), originalDoc.positionAt(info.textSpan.start + info.textSpan.length));
+    for (const entry of info.definitions) {
+        const entryUri = ctx.env.fileNameToUri(entry.fileName);
+        const doc = ctx.getTextDocument(entryUri);
+        if (!doc)
+            continue;
+        const targetSelectionRange = vscode.Range.create(doc.positionAt(entry.textSpan.start), doc.positionAt(entry.textSpan.start + entry.textSpan.length));
+        const targetRange = entry.contextSpan ? vscode.Range.create(doc.positionAt(entry.contextSpan.start), doc.positionAt(entry.contextSpan.start + entry.contextSpan.length)) : targetSelectionRange;
+        const location = vscode.LocationLink.create(entryUri, targetRange, targetSelectionRange, originSelectionRange);
+        locations.push(location);
+    }
+    return locations;
+}
+exports.boundSpanToLocationLinks = boundSpanToLocationLinks;
+//# sourceMappingURL=transforms.js.map

package/out/utils/typeConverters.d.ts

@@ -0,0 +1,4 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare namespace SymbolKind {
+    function fromProtocolScriptElementKind(kind: ts.ScriptElementKind): 2 | 5 | 10 | 22 | 11 | 6 | 7 | 13 | 12 | 9 | 26 | 15;
+}

package/out/utils/typeConverters.js

@@ -0,0 +1,67 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolKind = void 0;
+/**
+ * Helpers for converting FROM vscode types TO ts types
+ */
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const PConst = __importStar(require("../protocol.const"));
+var SymbolKind;
+(function (SymbolKind) {
+    function fromProtocolScriptElementKind(kind) {
+        switch (kind) {
+            case PConst.Kind.module: return vscode.SymbolKind.Module;
+            case PConst.Kind.class: return vscode.SymbolKind.Class;
+            case PConst.Kind.enum: return vscode.SymbolKind.Enum;
+            case PConst.Kind.enumMember: return vscode.SymbolKind.EnumMember;
+            case PConst.Kind.interface: return vscode.SymbolKind.Interface;
+            case PConst.Kind.indexSignature: return vscode.SymbolKind.Method;
+            case PConst.Kind.callSignature: return vscode.SymbolKind.Method;
+            case PConst.Kind.method: return vscode.SymbolKind.Method;
+            case PConst.Kind.memberVariable: return vscode.SymbolKind.Property;
+            case PConst.Kind.memberGetAccessor: return vscode.SymbolKind.Property;
+            case PConst.Kind.memberSetAccessor: return vscode.SymbolKind.Property;
+            case PConst.Kind.variable: return vscode.SymbolKind.Variable;
+            case PConst.Kind.let: return vscode.SymbolKind.Variable;
+            case PConst.Kind.const: return vscode.SymbolKind.Variable;
+            case PConst.Kind.localVariable: return vscode.SymbolKind.Variable;
+            case PConst.Kind.alias: return vscode.SymbolKind.Variable;
+            case PConst.Kind.function: return vscode.SymbolKind.Function;
+            case PConst.Kind.localFunction: return vscode.SymbolKind.Function;
+            case PConst.Kind.constructSignature: return vscode.SymbolKind.Constructor;
+            case PConst.Kind.constructorImplementation: return vscode.SymbolKind.Constructor;
+            case PConst.Kind.typeParameter: return vscode.SymbolKind.TypeParameter;
+            case PConst.Kind.string: return vscode.SymbolKind.String;
+            default: return vscode.SymbolKind.Variable;
+        }
+    }
+    SymbolKind.fromProtocolScriptElementKind = fromProtocolScriptElementKind;
+})(SymbolKind = exports.SymbolKind || (exports.SymbolKind = {}));
+//# sourceMappingURL=typeConverters.js.map

package/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "volar-service-typescript",
+	"version": "0.0.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"rules.d.ts",
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/services.git",
+		"directory": "packages/typescript"
+	},
+	"devDependencies": {
+		"@types/semver": "^7.3.13"
+	},
+	"dependencies": {
+		"jsonc-parser": "^3.2.0",
+		"minimatch": "^9.0.0",
+		"semver": "^7.3.8",
+		"vscode-languageserver-protocol": "^3.17.3",
+		"vscode-languageserver-textdocument": "^1.0.8",
+		"vscode-nls": "^5.2.0",
+		"vscode-uri": "^3.0.7"
+	},
+	"peerDependencies": {
+		"@volar/language-service": "*"
+	},
+	"gitHead": "1011561ac4bbf79c53c3b80c27692569bf861519"
+}

package/rules.d.ts

@@ -0,0 +1,13 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+
+declare module '@volar/language-service' {
+	interface RuleContext {
+		typescript?: {
+			sourceFile: ts.SourceFile;
+			getTextDocument(uri: string): TextDocument | undefined;
+			languageService: ts.LanguageService;
+			languageServiceHost: ts.LanguageServiceHost;
+		}
+	}
+}