volar-service-typescript 0.0.3 → 0.0.5

package/out/configs/getFormatCodeSettings.d.ts

@@ -1,5 +1,5 @@
 import { SharedContext } from '../types';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-import * as vscode from 'vscode-languageserver-protocol';
+import type { FormattingOptions } from '@volar/language-service';
 import type { TextDocument } from 'vscode-languageserver-textdocument';
-export declare function getFormatCodeSettings(ctx: SharedContext, document: TextDocument, options?: vscode.FormattingOptions): Promise<ts.FormatCodeSettings>;
+export declare function getFormatCodeSettings(ctx: SharedContext, document: TextDocument, options?: FormattingOptions): Promise<ts.FormatCodeSettings>;

package/out/features/callHierarchy.d.ts

@@ -0,0 +1,7 @@
+import type * as vscode from '@volar/language-service';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): {
+    doPrepare: (uri: string, position: vscode.Position) => vscode.CallHierarchyItem[];
+    getIncomingCalls: (item: vscode.CallHierarchyItem) => vscode.CallHierarchyIncomingCall[];
+    getOutgoingCalls: (item: vscode.CallHierarchyItem) => vscode.CallHierarchyOutgoingCall[];
+};

package/out/features/callHierarchy.js

@@ -0,0 +1,125 @@
+"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 modifiers_1 = require("../utils/modifiers");
+const typeConverters = __importStar(require("../utils/typeConverters"));
+const path_1 = require("path");
+const shared_1 = require("../shared");
+function register(ctx) {
+    function doPrepare(uri, position) {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const calls = (0, shared_1.safeCall)(() => ctx.typescript.languageService.prepareCallHierarchy(fileName, offset));
+        if (!calls)
+            return [];
+        const items = Array.isArray(calls) ? calls : [calls];
+        return items.map(item => fromProtocolCallHierarchyItem(item));
+    }
+    function getIncomingCalls(item) {
+        const document = ctx.getTextDocument(item.uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(item.uri);
+        const offset = document.offsetAt(item.selectionRange.start);
+        const calls = (0, shared_1.safeCall)(() => ctx.typescript.languageService.provideCallHierarchyIncomingCalls(fileName, offset));
+        if (!calls)
+            return [];
+        const items = Array.isArray(calls) ? calls : [calls];
+        return items.map(item => fromProtocolCallHierarchyIncomingCall(item));
+    }
+    function getOutgoingCalls(item) {
+        const document = ctx.getTextDocument(item.uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(item.uri);
+        const offset = document.offsetAt(item.selectionRange.start);
+        const calls = (0, shared_1.safeCall)(() => ctx.typescript.languageService.provideCallHierarchyOutgoingCalls(fileName, offset));
+        if (!calls)
+            return [];
+        const items = Array.isArray(calls) ? calls : [calls];
+        return items.map(item => fromProtocolCallHierarchyOutgoingCall(item, document));
+    }
+    return {
+        doPrepare,
+        getIncomingCalls,
+        getOutgoingCalls,
+    };
+    function isSourceFileItem(item) {
+        return item.kind === PConst.Kind.script || item.kind === PConst.Kind.module && item.selectionSpan.start === 0;
+    }
+    function fromProtocolCallHierarchyItem(item) {
+        const rootPath = ctx.typescript.languageService.getProgram()?.getCompilerOptions().rootDir ?? '';
+        const document = ctx.getTextDocument(ctx.env.fileNameToUri(item.file)); // TODO
+        const useFileName = isSourceFileItem(item);
+        const name = useFileName ? path_1.posix.basename(item.file) : item.name;
+        const detail = useFileName ? path_1.posix.relative(rootPath, path_1.posix.dirname(item.file)) : item.containerName ?? '';
+        const result = {
+            kind: typeConverters.SymbolKind.fromProtocolScriptElementKind(item.kind),
+            name,
+            detail,
+            uri: ctx.env.fileNameToUri(item.file),
+            range: {
+                start: document.positionAt(item.span.start),
+                end: document.positionAt(item.span.start + item.span.length),
+            },
+            selectionRange: {
+                start: document.positionAt(item.selectionSpan.start),
+                end: document.positionAt(item.selectionSpan.start + item.selectionSpan.length),
+            },
+        };
+        const kindModifiers = item.kindModifiers ? (0, modifiers_1.parseKindModifier)(item.kindModifiers) : undefined;
+        if (kindModifiers?.has(PConst.KindModifiers.deprecated)) {
+            result.tags = [1];
+        }
+        return result;
+    }
+    function fromProtocolCallHierarchyIncomingCall(item) {
+        const document = ctx.getTextDocument(ctx.env.fileNameToUri(item.from.file));
+        return {
+            from: fromProtocolCallHierarchyItem(item.from),
+            fromRanges: item.fromSpans.map(fromSpan => ({
+                start: document.positionAt(fromSpan.start),
+                end: document.positionAt(fromSpan.start + fromSpan.length),
+            })),
+        };
+    }
+    function fromProtocolCallHierarchyOutgoingCall(item, document) {
+        return {
+            to: fromProtocolCallHierarchyItem(item.to),
+            fromRanges: item.fromSpans.map(fromSpan => ({
+                start: document.positionAt(fromSpan.start),
+                end: document.positionAt(fromSpan.start + fromSpan.length),
+            })),
+        };
+    }
+}
+exports.register = register;
+;
+//# sourceMappingURL=callHierarchy.js.map

package/out/features/codeAction.d.ts

@@ -0,0 +1,26 @@
+import type * as vscode from '@volar/language-service';
+import { SharedContext } from '../types';
+export interface FixAllData {
+    type: 'fixAll';
+    uri: string;
+    fileName: string;
+    fixIds: {}[];
+}
+export interface RefactorData {
+    type: 'refactor';
+    uri: string;
+    fileName: string;
+    refactorName: string;
+    actionName: string;
+    range: {
+        pos: number;
+        end: number;
+    };
+}
+export interface OrganizeImportsData {
+    type: 'organizeImports';
+    uri: string;
+    fileName: string;
+}
+export type Data = FixAllData | RefactorData | OrganizeImportsData;
+export declare function register(ctx: SharedContext): (uri: string, range: vscode.Range, context: vscode.CodeActionContext) => Promise<vscode.CodeAction[] | undefined>;

package/out/features/codeAction.js

@@ -0,0 +1,263 @@
+"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 rename_1 = require("./rename");
+const fixNames = __importStar(require("../utils/fixNames"));
+const getFormatCodeSettings_1 = require("../configs/getFormatCodeSettings");
+const getUserPreferences_1 = require("../configs/getUserPreferences");
+const shared_1 = require("../shared");
+const codeActionResolve_1 = require("./codeActionResolve");
+function register(ctx) {
+    let resolveCommandSupport = ctx.env.clientCapabilities?.textDocument?.codeAction?.resolveSupport?.properties?.includes('command');
+    let resolveEditSupport = ctx.env.clientCapabilities?.textDocument?.codeAction?.resolveSupport?.properties?.includes('edit');
+    if (!ctx.env.clientCapabilities) {
+        resolveCommandSupport = true;
+        resolveEditSupport = true;
+    }
+    return async (uri, range, context) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const [formatOptions, preferences] = await Promise.all([
+            (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document),
+            (0, getUserPreferences_1.getUserPreferences)(ctx, document),
+        ]);
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const start = document.offsetAt(range.start);
+        const end = document.offsetAt(range.end);
+        let result = [];
+        const onlyQuickFix = matchOnlyKind(`${'quickfix'}.ts`);
+        if (!context.only || onlyQuickFix) {
+            for (const error of context.diagnostics) {
+                const codeFixes = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getCodeFixesAtPosition(fileName, document.offsetAt(error.range.start), document.offsetAt(error.range.end), [Number(error.code)], formatOptions, preferences)) ?? [];
+                for (const codeFix of codeFixes) {
+                    result = result.concat(transformCodeFix(codeFix, [error], onlyQuickFix ?? ''));
+                }
+            }
+        }
+        if (context.only) {
+            for (const only of context.only) {
+                if (only.split('.')[0] === 'refactor') {
+                    const refactors = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getApplicableRefactors(fileName, { pos: start, end: end }, preferences, undefined, only)) ?? [];
+                    for (const refactor of refactors) {
+                        result = result.concat(transformRefactor(refactor));
+                    }
+                }
+            }
+        }
+        else {
+            const refactors = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getApplicableRefactors(fileName, { pos: start, end: end }, preferences, undefined, undefined)) ?? [];
+            for (const refactor of refactors) {
+                result = result.concat(transformRefactor(refactor));
+            }
+        }
+        const onlySourceOrganizeImports = matchOnlyKind(`${'source.organizeImports'}.ts`);
+        if (onlySourceOrganizeImports) {
+            const action = {
+                title: 'Organize Imports',
+                kind: onlySourceOrganizeImports,
+            };
+            const data = {
+                type: 'organizeImports',
+                uri,
+                fileName,
+            };
+            if (resolveEditSupport) {
+                action.data = data;
+            }
+            else {
+                (0, codeActionResolve_1.resolveOrganizeImportsCodeAction)(ctx, action, data, formatOptions, preferences);
+            }
+            result.push(action);
+        }
+        const onlySourceFixAll = matchOnlyKind(`${'source.fixAll'}.ts`);
+        if (onlySourceFixAll) {
+            const action = {
+                title: 'Fix All',
+                kind: onlySourceFixAll,
+            };
+            const data = {
+                uri,
+                type: 'fixAll',
+                fileName,
+                fixIds: [
+                    fixNames.classIncorrectlyImplementsInterface,
+                    fixNames.awaitInSyncFunction,
+                    fixNames.unreachableCode,
+                ],
+            };
+            if (resolveEditSupport) {
+                action.data = data;
+            }
+            else {
+                (0, codeActionResolve_1.resolveFixAllCodeAction)(ctx, action, data, formatOptions, preferences);
+            }
+            result.push(action);
+        }
+        const onlyRemoveUnused = matchOnlyKind(`${'source'}.removeUnused.ts`);
+        if (onlyRemoveUnused) {
+            const action = {
+                title: 'Remove all unused code',
+                kind: onlyRemoveUnused,
+            };
+            const data = {
+                uri,
+                type: 'fixAll',
+                fileName,
+                fixIds: [
+                    // not working and throw
+                    fixNames.unusedIdentifier,
+                    // TODO: remove patching
+                    'unusedIdentifier_prefix',
+                    'unusedIdentifier_deleteImports',
+                    'unusedIdentifier_delete',
+                    'unusedIdentifier_infer',
+                ],
+            };
+            if (resolveEditSupport) {
+                action.data = data;
+            }
+            else {
+                (0, codeActionResolve_1.resolveFixAllCodeAction)(ctx, action, data, formatOptions, preferences);
+            }
+            result.push(action);
+        }
+        const onlyAddMissingImports = matchOnlyKind(`${'source'}.addMissingImports.ts`);
+        if (onlyAddMissingImports) {
+            const action = {
+                title: 'Add all missing imports',
+                kind: onlyAddMissingImports,
+            };
+            const data = {
+                uri,
+                type: 'fixAll',
+                fileName,
+                fixIds: [
+                    // not working and throw
+                    fixNames.fixImport,
+                    // TODO: remove patching
+                    'fixMissingImport',
+                ],
+            };
+            if (resolveEditSupport) {
+                action.data = data;
+            }
+            else {
+                (0, codeActionResolve_1.resolveFixAllCodeAction)(ctx, action, data, formatOptions, preferences);
+            }
+            result.push(action);
+        }
+        for (const codeAction of result) {
+            if (codeAction.diagnostics === undefined) {
+                codeAction.diagnostics = context.diagnostics;
+            }
+        }
+        return result;
+        function matchOnlyKind(kind) {
+            if (context.only) {
+                for (const only of context.only) {
+                    const a = only.split('.');
+                    const b = kind.split('.');
+                    if (a.length <= b.length) {
+                        let matchNums = 0;
+                        for (let i = 0; i < a.length; i++) {
+                            if (a[i] == b[i]) {
+                                matchNums++;
+                            }
+                        }
+                        if (matchNums === a.length)
+                            return only;
+                    }
+                }
+            }
+        }
+        function transformCodeFix(codeFix, diagnostics, kind) {
+            const edit = (0, rename_1.fileTextChangesToWorkspaceEdit)(codeFix.changes, ctx);
+            const codeActions = [];
+            const fix = {
+                title: codeFix.description,
+                kind,
+                edit,
+            };
+            fix.diagnostics = diagnostics;
+            codeActions.push(fix);
+            if (codeFix.fixAllDescription && codeFix.fixId) {
+                const fixAll = {
+                    title: codeFix.fixAllDescription,
+                    kind,
+                };
+                const data = {
+                    uri,
+                    type: 'fixAll',
+                    fileName,
+                    fixIds: [codeFix.fixId],
+                };
+                if (resolveEditSupport) {
+                    fixAll.data = data;
+                }
+                else {
+                    (0, codeActionResolve_1.resolveFixAllCodeAction)(ctx, fixAll, data, formatOptions, preferences);
+                }
+                fixAll.diagnostics = diagnostics;
+                codeActions.push(fixAll);
+            }
+            return codeActions;
+        }
+        function transformRefactor(refactor) {
+            const codeActions = [];
+            for (const action of refactor.actions) {
+                const codeAction = {
+                    title: action.description,
+                    kind: action.kind,
+                };
+                if (action.notApplicableReason) {
+                    codeAction.disabled = { reason: action.notApplicableReason };
+                }
+                if (refactor.inlineable) {
+                    codeAction.isPreferred = true;
+                }
+                const data = {
+                    uri,
+                    type: 'refactor',
+                    fileName,
+                    range: { pos: start, end: end },
+                    refactorName: refactor.name,
+                    actionName: action.name,
+                };
+                if (resolveCommandSupport && resolveEditSupport) {
+                    codeAction.data = data;
+                }
+                else if (!codeAction.disabled && document) {
+                    (0, codeActionResolve_1.resolveRefactorCodeAction)(ctx, codeAction, data, document, formatOptions, preferences);
+                }
+                codeActions.push(codeAction);
+            }
+            return codeActions;
+        }
+    };
+}
+exports.register = register;
+//# sourceMappingURL=codeAction.js.map

package/out/features/codeActionResolve.d.ts

@@ -0,0 +1,9 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type * as vscode from '@volar/language-service';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { SharedContext } from '../types';
+import { Data, FixAllData, RefactorData } from './codeAction';
+export declare function register(ctx: SharedContext): (codeAction: vscode.CodeAction) => Promise<vscode.CodeAction>;
+export declare function resolveFixAllCodeAction(ctx: SharedContext, codeAction: vscode.CodeAction, data: FixAllData, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): void;
+export declare function resolveRefactorCodeAction(ctx: SharedContext, codeAction: vscode.CodeAction, data: RefactorData, document: TextDocument, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): void;
+export declare function resolveOrganizeImportsCodeAction(ctx: SharedContext, codeAction: vscode.CodeAction, data: Data, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): void;

package/out/features/codeActionResolve.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOrganizeImportsCodeAction = exports.resolveRefactorCodeAction = exports.resolveFixAllCodeAction = exports.register = void 0;
+const getFormatCodeSettings_1 = require("../configs/getFormatCodeSettings");
+const getUserPreferences_1 = require("../configs/getUserPreferences");
+const shared_1 = require("../shared");
+const rename_1 = require("./rename");
+function register(ctx) {
+    return async (codeAction) => {
+        const data = codeAction.data;
+        const document = ctx.getTextDocument(data.uri);
+        const [formatOptions, preferences] = document ? await Promise.all([
+            (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document),
+            (0, getUserPreferences_1.getUserPreferences)(ctx, document),
+        ]) : [{}, {}];
+        if (data?.type === 'fixAll') {
+            resolveFixAllCodeAction(ctx, codeAction, data, formatOptions, preferences);
+        }
+        else if (data?.type === 'refactor' && document) {
+            resolveRefactorCodeAction(ctx, codeAction, data, document, formatOptions, preferences);
+        }
+        else if (data?.type === 'organizeImports') {
+            resolveOrganizeImportsCodeAction(ctx, codeAction, data, formatOptions, preferences);
+        }
+        return codeAction;
+    };
+}
+exports.register = register;
+function resolveFixAllCodeAction(ctx, codeAction, data, formatOptions, preferences) {
+    const fixes = data.fixIds.map(fixId => (0, shared_1.safeCall)(() => ctx.typescript.languageService.getCombinedCodeFix({ type: 'file', fileName: data.fileName }, fixId, formatOptions, preferences)));
+    const changes = fixes.map(fix => fix?.changes ?? []).flat();
+    codeAction.edit = (0, rename_1.fileTextChangesToWorkspaceEdit)(changes, ctx);
+}
+exports.resolveFixAllCodeAction = resolveFixAllCodeAction;
+function resolveRefactorCodeAction(ctx, codeAction, data, document, formatOptions, preferences) {
+    const editInfo = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getEditsForRefactor(data.fileName, formatOptions, data.range, data.refactorName, data.actionName, preferences));
+    if (!editInfo) {
+        return;
+    }
+    codeAction.edit = (0, rename_1.fileTextChangesToWorkspaceEdit)(editInfo.edits, ctx);
+    if (editInfo.renameLocation !== undefined && editInfo.renameFilename !== undefined) {
+        codeAction.command = ctx.commands.rename.create(document.uri, document.positionAt(editInfo.renameLocation));
+    }
+}
+exports.resolveRefactorCodeAction = resolveRefactorCodeAction;
+function resolveOrganizeImportsCodeAction(ctx, codeAction, data, formatOptions, preferences) {
+    const changes = (0, shared_1.safeCall)(() => ctx.typescript.languageService.organizeImports({ type: 'file', fileName: data.fileName }, formatOptions, preferences));
+    codeAction.edit = (0, rename_1.fileTextChangesToWorkspaceEdit)(changes ?? [], ctx);
+}
+exports.resolveOrganizeImportsCodeAction = resolveOrganizeImportsCodeAction;
+//# sourceMappingURL=codeActionResolve.js.map

package/out/features/completions/basic.d.ts

@@ -0,0 +1,16 @@
+import { SharedContext } from '../../types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type * as vscode from '@volar/language-service';
+export interface Data {
+    uri: string;
+    fileName: string;
+    offset: number;
+    originalItem: {
+        name: ts.CompletionEntry['name'];
+        source: ts.CompletionEntry['source'];
+        data: ts.CompletionEntry['data'];
+        labelDetails: ts.CompletionEntry['labelDetails'];
+    };
+}
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position, options?: ts.GetCompletionsAtPositionOptions | undefined) => Promise<vscode.CompletionList | undefined>;
+export declare function handleKindModifiers(item: vscode.CompletionItem, tsEntry: ts.CompletionEntry | ts.CompletionEntryDetails): void;