@vue/language-server 1.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/vue-language-server.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+if (process.argv.includes("--version")) {
+	const pkgJSON = require("../package.json");
+	console.log(`${pkgJSON["version"]}`);
+}
+else {
+	require("../out/nodeServer.js");
+}

package/out/index.d.ts

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

package/out/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("./protocol"), exports);
+__exportStar(require("./types"), exports);
+// export protocol and types of parent package
+__exportStar(require("@volar/language-server/out/protocol"), exports);
+__exportStar(require("@volar/language-server/out/types"), exports);
+// only export types of depend packages
+__exportStar(require("@vue/language-service/out/types"), exports);
+//# sourceMappingURL=index.js.map

package/out/languageServerPlugin.d.ts

@@ -0,0 +1,2 @@
+import { LanguageServerPlugin, Connection } from '@volar/language-server';
+export declare function createServerPlugin(connection: Connection): LanguageServerPlugin;

package/out/languageServerPlugin.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerPlugin = void 0;
+const vue = require("@vue/language-service");
+const vue2 = require("@vue/language-core");
+const nameCasing = require("@vue/language-service");
+const protocol_1 = require("./protocol");
+const componentMeta = require("vue-component-meta");
+function createServerPlugin(connection) {
+    const plugin = (initOptions, modules) => {
+        if (!modules.typescript) {
+            console.warn('No typescript found, vue-language-server will not work.');
+            return {};
+        }
+        const ts = modules.typescript;
+        const vueFileExtensions = ['vue'];
+        const hostToVueOptions = new WeakMap();
+        if (initOptions.additionalExtensions) {
+            for (const additionalExtension of initOptions.additionalExtensions) {
+                vueFileExtensions.push(additionalExtension);
+            }
+        }
+        return {
+            extraFileExtensions: vueFileExtensions.map(ext => ({ extension: ext, isMixedContent: true, scriptKind: ts.ScriptKind.Deferred })),
+            watchFileExtensions: ['js', 'cjs', 'mjs', 'ts', 'cts', 'mts', 'jsx', 'tsx', 'json', ...vueFileExtensions],
+            resolveConfig(config, ctx) {
+                const vueOptions = getVueCompilerOptions();
+                const vueLanguageServiceSettings = getVueLanguageServiceSettings();
+                if (ctx) {
+                    hostToVueOptions.set(ctx.host, vueOptions);
+                }
+                return vue.resolveConfig(config, ctx?.host.getCompilationSettings() ?? {}, vueOptions, vueLanguageServiceSettings, ts);
+                function getVueCompilerOptions() {
+                    const ts = modules.typescript;
+                    let vueOptions;
+                    if (typeof ctx?.project.tsConfig === 'string' && ts) {
+                        vueOptions = vue2.createParsedCommandLine(ts, ctx.sys, ctx.project.tsConfig).vueOptions;
+                    }
+                    else if (typeof ctx?.project.tsConfig === 'object' && ts) {
+                        vueOptions = vue2.createParsedCommandLineByJson(ts, ctx.sys, ctx.host.getCurrentDirectory(), ctx.project.tsConfig).vueOptions;
+                    }
+                    else {
+                        vueOptions = vue2.resolveVueCompilerOptions({});
+                    }
+                    vueOptions.extensions = [
+                        ...vueOptions.extensions,
+                        ...vueFileExtensions.map(ext => '.' + ext),
+                    ];
+                    vueOptions.extensions = [...new Set(vueOptions.extensions)];
+                    return vueOptions;
+                }
+                function getVueLanguageServiceSettings() {
+                    const settings = {};
+                    if (initOptions.json && ctx) {
+                        settings.json = { schemas: [] };
+                        for (const blockType in initOptions.json.customBlockSchemaUrls) {
+                            const url = initOptions.json.customBlockSchemaUrls[blockType];
+                            settings.json.schemas?.push({
+                                fileMatch: [`*.customBlock_${blockType}_*.json*`],
+                                uri: new URL(url, ctx.project.rootUri.toString() + '/').toString(),
+                            });
+                        }
+                    }
+                    return settings;
+                }
+            },
+            onInitialized(getService, env) {
+                connection.onRequest(protocol_1.ParseSFCRequest.type, params => {
+                    return vue2.parse(params);
+                });
+                connection.onRequest(protocol_1.DetectNameCasingRequest.type, async (params) => {
+                    const languageService = await getService(params.textDocument.uri);
+                    if (languageService?.context.typescript) {
+                        return nameCasing.detect(ts, languageService.context, params.textDocument.uri);
+                    }
+                });
+                connection.onRequest(protocol_1.GetConvertTagCasingEditsRequest.type, async (params) => {
+                    const languageService = await getService(params.textDocument.uri);
+                    if (languageService?.context.typescript) {
+                        return nameCasing.convertTagName(ts, languageService.context, params.textDocument.uri, params.casing);
+                    }
+                });
+                connection.onRequest(protocol_1.GetConvertAttrCasingEditsRequest.type, async (params) => {
+                    const languageService = await getService(params.textDocument.uri);
+                    if (languageService?.context.typescript) {
+                        const vueOptions = hostToVueOptions.get(languageService.context.host);
+                        if (vueOptions) {
+                            return nameCasing.convertAttrName(ts, languageService.context, params.textDocument.uri, params.casing);
+                        }
+                    }
+                });
+                const checkers = new WeakMap();
+                connection.onRequest(protocol_1.GetComponentMeta.type, async (params) => {
+                    const languageService = await getService(params.uri);
+                    if (!languageService?.context.typescript)
+                        return;
+                    let checker = checkers.get(languageService.context.host);
+                    if (!checker) {
+                        checker = componentMeta.baseCreate({
+                            ...languageService.context.host,
+                            getVueCompilationSettings: () => hostToVueOptions.get(languageService.context.host),
+                        }, {}, languageService.context.host.getCurrentDirectory() + '/tsconfig.json.global.vue', ts);
+                        checkers.set(languageService.context.host, checker);
+                    }
+                    return checker.getComponentMeta(env.uriToFileName(params.uri));
+                });
+            },
+        };
+    };
+    return plugin;
+}
+exports.createServerPlugin = createServerPlugin;
+//# sourceMappingURL=languageServerPlugin.js.map

package/out/nodeServer.d.ts

@@ -0,0 +1 @@
+export {};

package/out/nodeServer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("@volar/language-server/node");
+const languageServerPlugin_1 = require("./languageServerPlugin");
+const connection = (0, node_1.createConnection)();
+const plugin = (0, languageServerPlugin_1.createServerPlugin)(connection);
+(0, node_1.startLanguageServer)(connection, plugin);
+//# sourceMappingURL=nodeServer.js.map

package/out/protocol.d.ts

@@ -0,0 +1,44 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { TagNameCasing, AttrNameCasing, SFCParseResult } from '@vue/language-service';
+import { ComponentMeta } from 'vue-component-meta';
+export declare namespace GetComponentMeta {
+    type ParamsType = vscode.TextDocumentIdentifier;
+    type ResponseType = ComponentMeta | null | undefined;
+    type ErrorType = never;
+    const type: vscode.RequestType<vscode.TextDocumentIdentifier, ResponseType, never>;
+}
+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/out/protocol.js

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

package/out/types.d.ts

@@ -0,0 +1,10 @@
+import { InitializationOptions } from "@volar/language-server";
+export type VueServerInitializationOptions = InitializationOptions & {
+    json?: {
+        customBlockSchemaUrls?: Record<string, string>;
+    };
+    /**
+     * @example ['vue1', 'vue2']
+     */
+    additionalExtensions?: string[];
+};

package/out/types.js

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

package/out/webServer.d.ts

@@ -0,0 +1 @@
+export {};

package/out/webServer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const browser_1 = require("@volar/language-server/browser");
+const languageServerPlugin_1 = require("./languageServerPlugin");
+const connection = (0, browser_1.createConnection)();
+const plugin = (0, languageServerPlugin_1.createServerPlugin)(connection);
+(0, browser_1.startLanguageServer)(connection, plugin);
+//# sourceMappingURL=webServer.js.map

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@vue/language-server",
+	"version": "1.7.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"bin": {
+		"vue-language-server": "./bin/vue-language-server.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/vuejs/language-tools.git",
+		"directory": "packages/vue-language-server"
+	},
+	"dependencies": {
+		"@volar/language-core": "1.5.4",
+		"@volar/language-server": "1.5.4",
+		"@vue/language-core": "1.7.0",
+		"@vue/language-service": "1.7.0",
+		"vscode-languageserver-protocol": "^3.17.3",
+		"vue-component-meta": "1.7.0"
+	}
+}