@vue/language-server 2.0.0 → 2.0.1

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/protocol';
+export * from './lib/types';
+export * from '@volar/language-server/protocol';
+export * from '@volar/language-server/lib/types';
+export * from '@vue/language-service/lib/types';

package/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/protocol"), exports);
+__exportStar(require("./lib/types"), exports);
+// export protocol and types of parent package
+__exportStar(require("@volar/language-server/protocol"), exports);
+__exportStar(require("@volar/language-server/lib/types"), exports);
+// only export types of depend packages
+__exportStar(require("@vue/language-service/lib/types"), exports);
+//# sourceMappingURL=index.js.map

package/lib/protocol.d.ts

@@ -0,0 +1,37 @@
+import type { AttrNameCasing, SFCParseResult, TagNameCasing } from '@vue/language-service';
+import * as vscode from 'vscode-languageserver-protocol';
+export declare namespace DetectNameCasingRequest {
+    type ParamsType = {
+        textDocument: vscode.TextDocumentIdentifier;
+    };
+    type ResponseType = {
+        tag: TagNameCasing[];
+        attr: AttrNameCasing[];
+    } | null | undefined;
+    type ErrorType = never;
+    const type: vscode.RequestType<ParamsType, ResponseType, never>;
+}
+export declare namespace GetConvertTagCasingEditsRequest {
+    type ParamsType = {
+        textDocument: vscode.TextDocumentIdentifier;
+        casing: TagNameCasing;
+    };
+    type ResponseType = vscode.TextEdit[] | null | undefined;
+    type ErrorType = never;
+    const type: vscode.RequestType<ParamsType, ResponseType, never>;
+}
+export declare namespace GetConvertAttrCasingEditsRequest {
+    type ParamsType = {
+        textDocument: vscode.TextDocumentIdentifier;
+        casing: AttrNameCasing;
+    };
+    type ResponseType = vscode.TextEdit[] | null | undefined;
+    type ErrorType = never;
+    const type: vscode.RequestType<ParamsType, ResponseType, never>;
+}
+export declare namespace ParseSFCRequest {
+    type ParamsType = string;
+    type ResponseType = SFCParseResult;
+    type ErrorType = never;
+    const type: vscode.RequestType<string, SFCParseResult, never>;
+}

package/lib/protocol.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseSFCRequest = exports.GetConvertAttrCasingEditsRequest = exports.GetConvertTagCasingEditsRequest = exports.DetectNameCasingRequest = void 0;
+const vscode = require("vscode-languageserver-protocol");
+var DetectNameCasingRequest;
+(function (DetectNameCasingRequest) {
+    DetectNameCasingRequest.type = new vscode.RequestType('vue/detectTagCasing');
+})(DetectNameCasingRequest || (exports.DetectNameCasingRequest = DetectNameCasingRequest = {}));
+var GetConvertTagCasingEditsRequest;
+(function (GetConvertTagCasingEditsRequest) {
+    GetConvertTagCasingEditsRequest.type = new vscode.RequestType('vue/convertTagNameCasing');
+})(GetConvertTagCasingEditsRequest || (exports.GetConvertTagCasingEditsRequest = GetConvertTagCasingEditsRequest = {}));
+var GetConvertAttrCasingEditsRequest;
+(function (GetConvertAttrCasingEditsRequest) {
+    GetConvertAttrCasingEditsRequest.type = new vscode.RequestType('vue/convertPropNameCasing');
+})(GetConvertAttrCasingEditsRequest || (exports.GetConvertAttrCasingEditsRequest = GetConvertAttrCasingEditsRequest = {}));
+var ParseSFCRequest;
+(function (ParseSFCRequest) {
+    ParseSFCRequest.type = new vscode.RequestType('vue/parseSfc');
+})(ParseSFCRequest || (exports.ParseSFCRequest = ParseSFCRequest = {}));
+//# sourceMappingURL=protocol.js.map

package/lib/types.d.ts

@@ -0,0 +1,12 @@
+import type { InitializationOptions } from "@volar/language-server";
+export type VueInitializationOptions = InitializationOptions & {
+    typescript: {
+        tsdk: string;
+    };
+    vue?: {
+        /**
+         * @example ['vue1', 'vue2']
+         */
+        additionalExtensions?: string[];
+    };
+};

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/node.d.ts

@@ -0,0 +1,11 @@
+import type { Connection } from '@volar/language-server';
+export declare const connection: Connection;
+export declare const server: {
+    initialize: (params: Omit<import("@volar/language-server").InitializeParams, "initializationOptions"> & {
+        initializationOptions?: import("@volar/language-server").InitializationOptions | undefined;
+    }, projectProviderFactory: import("@volar/language-server").ServerProjectProviderFactory, _serverOptions: import("@volar/language-server/lib/server").ServerOptions) => Promise<import("@volar/language-server").InitializeResult<any>>;
+    initialized: () => void;
+    shutdown: () => void;
+    readonly projects: import("@volar/language-server").ServerProjectProvider;
+    readonly env: import("@volar/language-server").ServerRuntimeEnvironment;
+};

package/node.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.server = exports.connection = void 0;
+const node_1 = require("@volar/language-server/node");
+const language_core_1 = require("@vue/language-core");
+const language_service_1 = require("@vue/language-service");
+const protocol_1 = require("./lib/protocol");
+exports.connection = (0, node_1.createConnection)();
+exports.server = (0, node_1.createServer)(exports.connection);
+const envToVueOptions = new WeakMap();
+let tsdk;
+exports.connection.listen();
+exports.connection.onInitialize(async (params) => {
+    const options = params.initializationOptions;
+    tsdk = (0, node_1.loadTsdkByPath)(options.typescript.tsdk, params.locale);
+    const vueFileExtensions = ['vue'];
+    if (options.vue?.additionalExtensions) {
+        for (const additionalExtension of options.vue.additionalExtensions) {
+            vueFileExtensions.push(additionalExtension);
+        }
+    }
+    const result = await exports.server.initialize(params, (0, node_1.createSimpleProjectProviderFactory)(), {
+        watchFileExtensions: ['js', 'cjs', 'mjs', 'ts', 'cts', 'mts', 'jsx', 'tsx', 'json', ...vueFileExtensions],
+        getServicePlugins() {
+            return (0, language_service_1.createVueServicePlugins)(tsdk.typescript, env => envToVueOptions.get(env));
+        },
+        async getLanguagePlugins(serviceEnv, projectContext) {
+            const [commandLine, vueOptions] = await parseCommandLine();
+            const resolvedVueOptions = (0, language_core_1.resolveVueCompilerOptions)(vueOptions);
+            const vueLanguagePlugin = (0, language_core_1.createVueLanguagePlugin)(tsdk.typescript, serviceEnv.typescript.uriToFileName, commandLine?.options ?? {}, resolvedVueOptions, options.codegenStack);
+            envToVueOptions.set(serviceEnv, resolvedVueOptions);
+            return [vueLanguagePlugin];
+            async function parseCommandLine() {
+                let commandLine;
+                let vueOptions = {};
+                if (projectContext.typescript) {
+                    const { sys } = projectContext.typescript;
+                    let sysVersion;
+                    let newSysVersion = await sys.sync();
+                    while (sysVersion !== newSysVersion) {
+                        sysVersion = newSysVersion;
+                        if (projectContext.typescript.configFileName) {
+                            commandLine = (0, language_core_1.createParsedCommandLine)(tsdk.typescript, sys, projectContext.typescript.configFileName);
+                        }
+                        newSysVersion = await sys.sync();
+                    }
+                }
+                if (commandLine) {
+                    vueOptions = commandLine.vueOptions;
+                }
+                vueOptions.extensions = [
+                    ...vueOptions.extensions ?? ['.vue'],
+                    ...vueFileExtensions.map(ext => '.' + ext),
+                ];
+                vueOptions.extensions = [...new Set(vueOptions.extensions)];
+                return [commandLine, vueOptions];
+            }
+        },
+    });
+    // handle by tsserver + @vue/typescript-plugin
+    result.capabilities.semanticTokensProvider = undefined;
+    return result;
+});
+exports.connection.onInitialized(() => {
+    exports.server.initialized();
+});
+exports.connection.onShutdown(() => {
+    exports.server.shutdown();
+});
+exports.connection.onRequest(protocol_1.ParseSFCRequest.type, params => {
+    return (0, language_core_1.parse)(params);
+});
+exports.connection.onRequest(protocol_1.DetectNameCasingRequest.type, async (params) => {
+    const languageService = await getService(params.textDocument.uri);
+    if (languageService) {
+        return await (0, language_service_1.detect)(languageService.context, params.textDocument.uri);
+    }
+});
+exports.connection.onRequest(protocol_1.GetConvertTagCasingEditsRequest.type, async (params) => {
+    const languageService = await getService(params.textDocument.uri);
+    if (languageService) {
+        return await (0, language_service_1.convertTagName)(languageService.context, params.textDocument.uri, params.casing);
+    }
+});
+exports.connection.onRequest(protocol_1.GetConvertAttrCasingEditsRequest.type, async (params) => {
+    const languageService = await getService(params.textDocument.uri);
+    if (languageService) {
+        return await (0, language_service_1.convertAttrName)(languageService.context, params.textDocument.uri, params.casing);
+    }
+});
+async function getService(uri) {
+    return (await exports.server.projects.getProject(uri)).getLanguageService();
+}
+//# sourceMappingURL=node.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@vue/language-server",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"license": "MIT",
 	"files": [
-		"out/**/*.js",
-		"out/**/*.d.ts"
+		"**/*.js",
+		"**/*.d.ts"
 	],
 	"bin": {
 		"vue-language-server": "./bin/vue-language-server.js"
@@ -17,9 +17,9 @@
 	"dependencies": {
 		"@volar/language-core": "~2.1.0",
 		"@volar/language-server": "~2.1.0",
-		"@vue/language-core": "2.0.0",
-		"@vue/language-service": "2.0.0",
+		"@vue/language-core": "2.0.1",
+		"@vue/language-service": "2.0.1",
 		"vscode-languageserver-protocol": "^3.17.5"
 	},
-	"gitHead": "aa47e5a7d8a6dae62cc80dbdb5db6a9bfa4f8715"
+	"gitHead": "adedfd0983c910370d080e955702cca7d2275420"
 }