@vue/language-service 2.0.0 → 2.0.1

package/lib/plugins/vue-sfc.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const vue = require("@vue/language-core");
+const volar_service_html_1 = require("volar-service-html");
+const html = require("vscode-html-languageservice");
+const data_1 = require("./data");
+let sfcDataProvider;
+function create() {
+    return {
+        name: 'vue-sfc',
+        create(context) {
+            const htmlPlugin = (0, volar_service_html_1.create)({
+                documentSelector: ['vue'],
+                useCustomDataProviders: false,
+            }).create(context);
+            const htmlLanguageService = htmlPlugin.provide['html/languageService']();
+            sfcDataProvider ??= html.newHTMLDataProvider('vue', (0, data_1.loadLanguageBlocks)(context.env.locale ?? 'en'));
+            htmlLanguageService.setDataProviders(false, [sfcDataProvider]);
+            return {
+                ...htmlPlugin,
+                provide: {
+                    'vue/vueFile': document => {
+                        return worker(document, (vueFile) => {
+                            return vueFile;
+                        });
+                    },
+                },
+                async resolveEmbeddedCodeFormattingOptions(code, options) {
+                    const sourceFile = context.language.files.getByVirtualCode(code);
+                    if (sourceFile.generated?.code instanceof vue.VueGeneratedCode) {
+                        if (code.id === 'scriptFormat' || code.id === 'scriptSetupFormat') {
+                            if (await context.env.getConfiguration?.('vue.format.script.initialIndent') ?? false) {
+                                options.initialIndentLevel++;
+                            }
+                        }
+                        else if (code.id.startsWith('style_')) {
+                            if (await context.env.getConfiguration?.('vue.format.style.initialIndent') ?? false) {
+                                options.initialIndentLevel++;
+                            }
+                        }
+                        else if (code.id === 'template') {
+                            if (await context.env.getConfiguration?.('vue.format.template.initialIndent') ?? true) {
+                                options.initialIndentLevel++;
+                            }
+                        }
+                    }
+                    return options;
+                },
+                provideDocumentLinks: undefined,
+                provideDocumentSymbols(document) {
+                    return worker(document, (vueSourceFile) => {
+                        const result = [];
+                        const descriptor = vueSourceFile.sfc;
+                        if (descriptor.template) {
+                            result.push({
+                                name: 'template',
+                                kind: 2,
+                                range: {
+                                    start: document.positionAt(descriptor.template.start),
+                                    end: document.positionAt(descriptor.template.end),
+                                },
+                                selectionRange: {
+                                    start: document.positionAt(descriptor.template.start),
+                                    end: document.positionAt(descriptor.template.startTagEnd),
+                                },
+                            });
+                        }
+                        if (descriptor.script) {
+                            result.push({
+                                name: 'script',
+                                kind: 2,
+                                range: {
+                                    start: document.positionAt(descriptor.script.start),
+                                    end: document.positionAt(descriptor.script.end),
+                                },
+                                selectionRange: {
+                                    start: document.positionAt(descriptor.script.start),
+                                    end: document.positionAt(descriptor.script.startTagEnd),
+                                },
+                            });
+                        }
+                        if (descriptor.scriptSetup) {
+                            result.push({
+                                name: 'script setup',
+                                kind: 2,
+                                range: {
+                                    start: document.positionAt(descriptor.scriptSetup.start),
+                                    end: document.positionAt(descriptor.scriptSetup.end),
+                                },
+                                selectionRange: {
+                                    start: document.positionAt(descriptor.scriptSetup.start),
+                                    end: document.positionAt(descriptor.scriptSetup.startTagEnd),
+                                },
+                            });
+                        }
+                        for (const style of descriptor.styles) {
+                            let name = 'style';
+                            if (style.scoped)
+                                name += ' scoped';
+                            if (style.module)
+                                name += ' module';
+                            result.push({
+                                name,
+                                kind: 2,
+                                range: {
+                                    start: document.positionAt(style.start),
+                                    end: document.positionAt(style.end),
+                                },
+                                selectionRange: {
+                                    start: document.positionAt(style.start),
+                                    end: document.positionAt(style.startTagEnd),
+                                },
+                            });
+                        }
+                        for (const customBlock of descriptor.customBlocks) {
+                            result.push({
+                                name: `${customBlock.type}`,
+                                kind: 2,
+                                range: {
+                                    start: document.positionAt(customBlock.start),
+                                    end: document.positionAt(customBlock.end),
+                                },
+                                selectionRange: {
+                                    start: document.positionAt(customBlock.start),
+                                    end: document.positionAt(customBlock.startTagEnd),
+                                },
+                            });
+                        }
+                        return result;
+                    });
+                },
+                provideDocumentFormattingEdits(document, range, options) {
+                    return worker(document, async (vueCode) => {
+                        const formatSettings = await context.env.getConfiguration?.('html.format') ?? {};
+                        const blockTypes = ['template', 'script', 'style'];
+                        for (const customBlock of vueCode.sfc.customBlocks) {
+                            blockTypes.push(customBlock.type);
+                        }
+                        return htmlLanguageService.format(document, range, {
+                            ...options,
+                            ...formatSettings,
+                            unformatted: '',
+                            contentUnformatted: blockTypes.join(','),
+                            extraLiners: blockTypes.join(','),
+                            endWithNewline: options.insertFinalNewline ? true
+                                : options.trimFinalNewlines ? false
+                                    : document.getText().endsWith('\n'),
+                        });
+                    });
+                },
+            };
+            function worker(document, callback) {
+                const [vueFile] = context.documents.getVirtualCodeByUri(document.uri);
+                if (vueFile instanceof vue.VueGeneratedCode) {
+                    return callback(vueFile);
+                }
+            }
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-sfc.js.map

package/lib/plugins/vue-template.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceEnvironment } from '@volar/language-service';
+import { ServicePlugin, VueCompilerOptions } from '../types';
+export declare function create(mode: 'html' | 'pug', ts: typeof import('typescript'), getVueOptions: (env: ServiceEnvironment) => VueCompilerOptions): ServicePlugin;