volar-service-typescript 0.0.0

package/out/services/completions/resolve.js

@@ -0,0 +1,170 @@
+"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.getLineText = exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const getFormatCodeSettings_1 = require("../../configs/getFormatCodeSettings");
+const getUserPreferences_1 = require("../../configs/getUserPreferences");
+const shared_1 = require("../../shared");
+const previewer = __importStar(require("../../utils/previewer"));
+const snippetForFunctionCall_1 = require("../../utils/snippetForFunctionCall");
+const transforms_1 = require("../../utils/transforms");
+const basic_1 = require("./basic");
+function register(ctx) {
+    const { ts } = ctx;
+    return async (item, newPosition) => {
+        const data = item.data;
+        if (!data)
+            return item;
+        const fileName = data.fileName;
+        let offset = data.offset;
+        const document = ctx.getTextDocument(data.uri);
+        if (newPosition && document) {
+            offset = document.offsetAt(newPosition);
+        }
+        const [formatOptions, preferences] = document ? await Promise.all([
+            (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document),
+            (0, getUserPreferences_1.getUserPreferences)(ctx, document),
+        ]) : [{}, {}];
+        let details;
+        try {
+            details = ctx.typescript.languageService.getCompletionEntryDetails(fileName, offset, data.originalItem.name, formatOptions, data.originalItem.source, preferences, data.originalItem.data);
+        }
+        catch (err) {
+            item.detail = `[TS Error]\n${err}\n${JSON.stringify(err, undefined, 2)}`;
+        }
+        if (!details)
+            return item;
+        if (data.originalItem.labelDetails) {
+            item.labelDetails ??= {};
+            Object.assign(item.labelDetails, data.originalItem.labelDetails);
+        }
+        const { sourceDisplay } = details;
+        if (sourceDisplay) {
+            item.labelDetails ??= {};
+            item.labelDetails.description = ts.displayPartsToString(sourceDisplay);
+        }
+        const detailTexts = [];
+        if (details.codeActions) {
+            if (!item.additionalTextEdits)
+                item.additionalTextEdits = [];
+            for (const action of details.codeActions) {
+                detailTexts.push(action.description);
+                for (const changes of action.changes) {
+                    const entries = changes.textChanges.map(textChange => {
+                        return { fileName, textSpan: textChange.span };
+                    });
+                    const locs = (0, transforms_1.entriesToLocations)(entries, ctx);
+                    locs.forEach((loc, index) => {
+                        item.additionalTextEdits?.push(vscode.TextEdit.replace(loc.range, changes.textChanges[index].newText));
+                    });
+                }
+            }
+        }
+        if (details.displayParts) {
+            detailTexts.push(previewer.plainWithLinks(details.displayParts, { toResource }, ctx));
+        }
+        if (detailTexts.length) {
+            item.detail = detailTexts.join('\n');
+        }
+        item.documentation = {
+            kind: 'markdown',
+            value: previewer.markdownDocumentation(details.documentation, details.tags, { toResource }, ctx),
+        };
+        if (details) {
+            (0, basic_1.handleKindModifiers)(item, details);
+        }
+        if (document) {
+            const useCodeSnippetsOnMethodSuggest = await ctx.env.getConfiguration?.((0, shared_1.getConfigTitle)(document) + '.suggest.completeFunctionCalls') ?? false;
+            const useCodeSnippet = useCodeSnippetsOnMethodSuggest && (item.kind === vscode.CompletionItemKind.Function || item.kind === vscode.CompletionItemKind.Method);
+            if (useCodeSnippet) {
+                const shouldCompleteFunction = isValidFunctionCompletionContext(ctx.typescript.languageService, fileName, offset, document);
+                if (shouldCompleteFunction) {
+                    const { snippet, parameterCount } = (0, snippetForFunctionCall_1.snippetForFunctionCall)({
+                        insertText: item.insertText ?? item.textEdit?.newText,
+                        label: item.label,
+                    }, details.displayParts);
+                    if (item.textEdit) {
+                        item.textEdit.newText = snippet;
+                    }
+                    if (item.insertText) {
+                        item.insertText = snippet;
+                    }
+                    item.insertTextFormat = vscode.InsertTextFormat.Snippet;
+                    if (parameterCount > 0) {
+                        //Fix for https://github.com/microsoft/vscode/issues/104059
+                        //Don't show parameter hints if "editor.parameterHints.enabled": false
+                        // if (await getConfiguration('editor.parameterHints.enabled', document.uri)) {
+                        // 	item.command = {
+                        // 		title: 'triggerParameterHints',
+                        // 		command: 'editor.action.triggerParameterHints',
+                        // 	};
+                        // }
+                    }
+                }
+            }
+        }
+        return item;
+        function toResource(path) {
+            return ctx.env.fileNameToUri(path);
+        }
+    };
+}
+exports.register = register;
+function isValidFunctionCompletionContext(client, filepath, offset, document) {
+    // Workaround for https://github.com/microsoft/TypeScript/issues/12677
+    // Don't complete function calls inside of destructive assignments or imports
+    try {
+        const response = client.getQuickInfoAtPosition(filepath, offset);
+        if (response) {
+            switch (response.kind) {
+                case 'var':
+                case 'let':
+                case 'const':
+                case 'alias':
+                    return false;
+            }
+        }
+    }
+    catch {
+        // Noop
+    }
+    // Don't complete function call if there is already something that looks like a function call
+    // https://github.com/microsoft/vscode/issues/18131
+    const position = document.positionAt(offset);
+    const after = getLineText(document, position.line).slice(position.character);
+    return after.match(/^[a-z_$0-9]*\s*\(/gi) === null;
+}
+function getLineText(document, line) {
+    const endOffset = document.offsetAt({ line: line + 1, character: 0 });
+    const end = document.positionAt(endOffset);
+    const text = document.getText({
+        start: { line: line, character: 0 },
+        end: end.line === line ? end : document.positionAt(endOffset - 1),
+    });
+    return text;
+}
+exports.getLineText = getLineText;
+//# sourceMappingURL=resolve.js.map

package/out/services/definition.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position) => vscode.LocationLink[];

package/out/services/definition.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const transforms_1 = require("../utils/transforms");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return (uri, position) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const info = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getDefinitionAndBoundSpan(fileName, offset));
+        if (!info)
+            return [];
+        return (0, transforms_1.boundSpanToLocationLinks)(info, document, ctx);
+    };
+}
+exports.register = register;
+//# sourceMappingURL=definition.js.map

package/out/services/diagnostics.d.ts

@@ -0,0 +1,10 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, options: {
+    semantic?: boolean;
+    syntactic?: boolean;
+    suggestion?: boolean;
+    declaration?: boolean;
+}) => vscode.Diagnostic[];
+export declare function getEmitDeclarations(compilerOptions: ts.CompilerOptions): boolean;

package/out/services/diagnostics.js

@@ -0,0 +1,144 @@
+"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.getEmitDeclarations = exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const shared_1 = require("../shared");
+function register(ctx) {
+    const { ts } = ctx;
+    return (uri, options) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const program = ctx.typescript.languageService.getProgram();
+        const sourceFile = program?.getSourceFile(fileName);
+        if (!program || !sourceFile)
+            return [];
+        const token = {
+            isCancellationRequested() {
+                return ctx.typescript?.languageServiceHost.getCancellationToken?.().isCancellationRequested() ?? false;
+            },
+            throwIfCancellationRequested() { },
+        };
+        let errors = (0, shared_1.safeCall)(() => [
+            ...options.semantic ? program.getSemanticDiagnostics(sourceFile, token) : [],
+            ...options.syntactic ? program.getSyntacticDiagnostics(sourceFile, token) : [],
+            ...options.suggestion ? ctx.typescript.languageService.getSuggestionDiagnostics(fileName) : [],
+        ]) ?? [];
+        if (options.declaration && getEmitDeclarations(program.getCompilerOptions())) {
+            errors = errors.concat(program.getDeclarationDiagnostics(sourceFile, token));
+        }
+        return translateDiagnostics(document, errors);
+        function translateDiagnostics(document, input) {
+            return input.map(diag => translateDiagnostic(diag, document)).filter((v) => !!v);
+        }
+        function translateDiagnostic(diag, document) {
+            if (diag.start === undefined)
+                return;
+            if (diag.length === undefined)
+                return;
+            const diagnostic = {
+                range: {
+                    start: document.positionAt(diag.start),
+                    end: document.positionAt(diag.start + diag.length),
+                },
+                severity: translateErrorType(diag.category),
+                source: 'ts',
+                code: diag.code,
+                message: getMessageText(diag),
+            };
+            if (diag.relatedInformation) {
+                diagnostic.relatedInformation = diag.relatedInformation
+                    .map(rErr => translateDiagnosticRelated(rErr))
+                    .filter((v) => !!v);
+            }
+            if (diag.reportsUnnecessary) {
+                if (diagnostic.tags === undefined)
+                    diagnostic.tags = [];
+                diagnostic.tags.push(vscode.DiagnosticTag.Unnecessary);
+            }
+            if (diag.reportsDeprecated) {
+                if (diagnostic.tags === undefined)
+                    diagnostic.tags = [];
+                diagnostic.tags.push(vscode.DiagnosticTag.Deprecated);
+            }
+            return diagnostic;
+        }
+        function translateDiagnosticRelated(diag) {
+            if (diag.start === undefined)
+                return;
+            if (diag.length === undefined)
+                return;
+            let document;
+            if (diag.file) {
+                document = ctx.getTextDocument(ctx.env.fileNameToUri(diag.file.fileName));
+            }
+            if (!document)
+                return;
+            const diagnostic = {
+                location: {
+                    uri: document.uri,
+                    range: {
+                        start: document.positionAt(diag.start),
+                        end: document.positionAt(diag.start + diag.length),
+                    },
+                },
+                message: getMessageText(diag),
+            };
+            return diagnostic;
+        }
+        function translateErrorType(input) {
+            switch (input) {
+                case ts.DiagnosticCategory.Warning: return vscode.DiagnosticSeverity.Warning;
+                case ts.DiagnosticCategory.Error: return vscode.DiagnosticSeverity.Error;
+                case ts.DiagnosticCategory.Suggestion: return vscode.DiagnosticSeverity.Hint;
+                case ts.DiagnosticCategory.Message: return vscode.DiagnosticSeverity.Information;
+            }
+            return vscode.DiagnosticSeverity.Error;
+        }
+    };
+}
+exports.register = register;
+function getMessageText(diag, level = 0) {
+    let messageText = '  '.repeat(level);
+    if (typeof diag.messageText === 'string') {
+        messageText += diag.messageText;
+    }
+    else {
+        messageText += diag.messageText.messageText;
+        if (diag.messageText.next) {
+            for (const info of diag.messageText.next) {
+                messageText += '\n' + getMessageText(info, level + 1);
+            }
+        }
+    }
+    return messageText;
+}
+function getEmitDeclarations(compilerOptions) {
+    return !!(compilerOptions.declaration || compilerOptions.composite);
+}
+exports.getEmitDeclarations = getEmitDeclarations;
+//# sourceMappingURL=diagnostics.js.map

package/out/services/documentHighlight.d.ts

@@ -0,0 +1,3 @@
+import { SharedContext } from '../types';
+import * as vscode from 'vscode-languageserver-protocol';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position) => vscode.DocumentHighlight[];

package/out/services/documentHighlight.js

@@ -0,0 +1,56 @@
+"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.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const shared_1 = require("../shared");
+function register(ctx) {
+    const { ts } = ctx;
+    return (uri, position) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const highlights = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getDocumentHighlights(fileName, offset, [fileName]));
+        if (!highlights)
+            return [];
+        const results = [];
+        for (const highlight of highlights) {
+            for (const span of highlight.highlightSpans) {
+                results.push({
+                    kind: span.kind === ts.HighlightSpanKind.writtenReference ? vscode.DocumentHighlightKind.Write : vscode.DocumentHighlightKind.Read,
+                    range: {
+                        start: document.positionAt(span.textSpan.start),
+                        end: document.positionAt(span.textSpan.start + span.textSpan.length),
+                    },
+                });
+            }
+        }
+        return results;
+    };
+}
+exports.register = register;
+//# sourceMappingURL=documentHighlight.js.map

package/out/services/documentSymbol.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string) => vscode.DocumentSymbol[];

package/out/services/documentSymbol.js

@@ -0,0 +1,106 @@
+"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.register = void 0;
+const PConst = __importStar(require("../protocol.const"));
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const modifiers_1 = require("../utils/modifiers");
+const shared_1 = require("../shared");
+const getSymbolKind = (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.interface: return vscode.SymbolKind.Interface;
+        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.const: return vscode.SymbolKind.Variable;
+        case PConst.Kind.localVariable: 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;
+    }
+    return vscode.SymbolKind.Variable;
+};
+function register(ctx) {
+    return (uri) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const barItems = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getNavigationTree(fileName));
+        if (!barItems)
+            return [];
+        // The root represents the file. Ignore this when showing in the UI
+        const result = barItems.childItems
+            ?.map(function convertNavTree(item) {
+            if (!shouldIncludeEntry(item)) {
+                return [];
+            }
+            let remain = item.childItems ?? [];
+            return item.spans.map(span => {
+                const childItems = [];
+                remain = remain.filter(child => {
+                    const childStart = child.spans[0].start;
+                    const childEnd = child.spans[child.spans.length - 1].start + child.spans[child.spans.length - 1].length;
+                    if (childStart >= span.start && childEnd <= span.start + span.length) {
+                        childItems.push(child);
+                        return false;
+                    }
+                    return true;
+                });
+                const nameSpan = item.spans.length === 1
+                    ? (item.nameSpan ?? span)
+                    : span;
+                const fullRange = {
+                    start: Math.min(span.start, nameSpan.start),
+                    end: Math.max(span.start + span.length, nameSpan.start + nameSpan.length),
+                };
+                const symbol = vscode.DocumentSymbol.create(item.text, undefined, getSymbolKind(item.kind), vscode.Range.create(document.positionAt(fullRange.start), document.positionAt(fullRange.end)), vscode.Range.create(document.positionAt(nameSpan.start), document.positionAt(nameSpan.start + nameSpan.length)), childItems.map(convertNavTree).flat());
+                const kindModifiers = (0, modifiers_1.parseKindModifier)(item.kindModifiers);
+                if (kindModifiers.has(PConst.KindModifiers.deprecated)) {
+                    symbol.deprecated = true;
+                    symbol.tags ??= [];
+                    symbol.tags.push(vscode.SymbolTag.Deprecated);
+                }
+                return symbol;
+            });
+        })
+            .flat();
+        return result ?? [];
+        function shouldIncludeEntry(item) {
+            if (item.kind === PConst.Kind.alias) {
+                return false;
+            }
+            return !!(item.text && item.text !== '<function>' && item.text !== '<class>');
+        }
+    };
+}
+exports.register = register;
+//# sourceMappingURL=documentSymbol.js.map

package/out/services/fileReferences.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string) => vscode.Location[];

package/out/services/fileReferences.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const transforms_1 = require("../utils/transforms");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return (uri) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const entries = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getFileReferences(fileName));
+        if (!entries)
+            return [];
+        return (0, transforms_1.entriesToLocations)([...entries], ctx);
+    };
+}
+exports.register = register;
+//# sourceMappingURL=fileReferences.js.map

package/out/services/fileRename.d.ts

@@ -0,0 +1,3 @@
+import type * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (oldUri: string, newUri: string) => Promise<vscode.WorkspaceEdit | undefined>;

package/out/services/fileRename.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const rename_1 = require("./rename");
+const getFormatCodeSettings_1 = require("../configs/getFormatCodeSettings");
+const getUserPreferences_1 = require("../configs/getUserPreferences");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return async (oldUri, newUri) => {
+        const document = ctx.getTextDocument(oldUri);
+        const [formatOptions, preferences] = document ? await Promise.all([
+            (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document),
+            (0, getUserPreferences_1.getUserPreferences)(ctx, document),
+        ]) : [{}, {}];
+        const fileToRename = ctx.env.uriToFileName(oldUri);
+        const newFilePath = ctx.env.uriToFileName(newUri);
+        const response = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getEditsForFileRename(fileToRename, newFilePath, formatOptions, preferences));
+        if (!response?.length)
+            return;
+        const edits = (0, rename_1.fileTextChangesToWorkspaceEdit)(response, ctx);
+        return edits;
+    };
+}
+exports.register = register;
+//# sourceMappingURL=fileRename.js.map

package/out/services/foldingRanges.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string) => vscode.FoldingRange[];

package/out/services/foldingRanges.js

@@ -0,0 +1,73 @@
+"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.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const shared_1 = require("../shared");
+function register(ctx) {
+    const { ts } = ctx;
+    return (uri) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const outliningSpans = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getOutliningSpans(fileName));
+        if (!outliningSpans)
+            return [];
+        const foldingRanges = [];
+        for (const outliningSpan of outliningSpans) {
+            const start = document.positionAt(outliningSpan.textSpan.start);
+            const end = adjustFoldingEnd(start, document.positionAt(outliningSpan.textSpan.start + outliningSpan.textSpan.length), document);
+            const foldingRange = vscode.FoldingRange.create(start.line, end.line, start.character, end.character, transformFoldingRangeKind(outliningSpan.kind));
+            foldingRanges.push(foldingRange);
+        }
+        return foldingRanges;
+    };
+    function transformFoldingRangeKind(tsKind) {
+        switch (tsKind) {
+            case ts.OutliningSpanKind.Comment: return vscode.FoldingRangeKind.Comment;
+            case ts.OutliningSpanKind.Imports: return vscode.FoldingRangeKind.Imports;
+            case ts.OutliningSpanKind.Region: return vscode.FoldingRangeKind.Region;
+        }
+    }
+}
+exports.register = register;
+const foldEndPairCharacters = ['}', ']', ')', '`'];
+// https://github.com/microsoft/vscode/blob/bed61166fb604e519e82e4d1d1ed839bc45d65f8/extensions/typescript-language-features/src/languageFeatures/folding.ts#L61-L73
+function adjustFoldingEnd(start, end, document) {
+    // workaround for #47240
+    if (end.character > 0) {
+        const foldEndCharacter = document.getText({
+            start: { line: end.line, character: end.character - 1 },
+            end,
+        });
+        if (foldEndPairCharacters.includes(foldEndCharacter)) {
+            const endOffset = Math.max(document.offsetAt({ line: end.line, character: 0 }) - 1, document.offsetAt(start));
+            return document.positionAt(endOffset);
+        }
+    }
+    return end;
+}
+//# sourceMappingURL=foldingRanges.js.map

package/out/services/formatting.d.ts

@@ -0,0 +1,6 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): {
+    onRange: (uri: string, range: vscode.Range | undefined, options: vscode.FormattingOptions) => Promise<vscode.TextEdit[]>;
+    onType: (uri: string, options: vscode.FormattingOptions, position: vscode.Position, key: string) => Promise<vscode.TextEdit[]>;
+};