@vue/language-service 2.0.0 → 2.0.1

package/lib/plugins/vue-toggle-v-bind-codeaction.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const language_core_1 = require("@vue/language-core");
+function create(ts) {
+    return {
+        name: 'vue-toggle-v-bind-codeaction',
+        create(context) {
+            return {
+                provideCodeActions(document, range, _context) {
+                    const startOffset = document.offsetAt(range.start);
+                    const endOffset = document.offsetAt(range.end);
+                    const [virtualCode] = context.documents.getVirtualCodeByUri(document.uri);
+                    if (!(virtualCode instanceof language_core_1.VueGeneratedCode)) {
+                        return;
+                    }
+                    const { template } = virtualCode.sfc;
+                    if (!template?.ast)
+                        return;
+                    const templateStartOffset = template.startTagEnd;
+                    const result = [];
+                    for (const node of (0, language_core_1.eachElementNode)(template.ast)) {
+                        if (startOffset > templateStartOffset + node.loc.end.offset || endOffset < templateStartOffset + node.loc.start.offset) {
+                            return;
+                        }
+                        for (const prop of node.props) {
+                            if (startOffset - templateStartOffset >= prop.loc.start.offset
+                                && endOffset - templateStartOffset <= prop.loc.end.offset) {
+                                if (prop.type === 7 && prop.exp) {
+                                    const sourceFile = ts.createSourceFile('/a.ts', prop.exp.loc.source, ts.ScriptTarget.Latest, true);
+                                    const firstStatement = sourceFile.statements[0];
+                                    if (sourceFile.statements.length === 1 && ts.isExpressionStatement(firstStatement) && ts.isStringLiteralLike(firstStatement.expression)) {
+                                        const stringNode = sourceFile.statements[0];
+                                        const removeTextRanges = [
+                                            [prop.loc.start.offset, prop.loc.start.offset + 1],
+                                            // Work correctly with trivias for cases like <input :type=" 'password' " />
+                                            [prop.exp.loc.start.offset, prop.exp.loc.start.offset + stringNode.pos + stringNode.getLeadingTriviaWidth() + 1],
+                                            [prop.exp.loc.start.offset + stringNode.end - 1, prop.exp.loc.end.offset],
+                                        ];
+                                        result.push({
+                                            title: 'Remove v-bind from attribute',
+                                            kind: 'refactor.rewrite.removeVBind',
+                                            edit: {
+                                                changes: {
+                                                    [document.uri]: removeTextRanges.map(range => ({
+                                                        newText: '',
+                                                        range: {
+                                                            start: document.positionAt(templateStartOffset + range[0]),
+                                                            end: document.positionAt(templateStartOffset + range[1]),
+                                                        }
+                                                    }))
+                                                },
+                                            },
+                                        });
+                                    }
+                                }
+                                if (prop.type === 6) {
+                                    const edits = [];
+                                    const addVBindPos = document.positionAt(templateStartOffset + prop.loc.start.offset);
+                                    edits.push({
+                                        newText: ':',
+                                        range: {
+                                            start: addVBindPos,
+                                            end: addVBindPos,
+                                        },
+                                    });
+                                    let newPosition;
+                                    if (prop.value) {
+                                        const valueStart = document.positionAt(templateStartOffset + prop.value.loc.start.offset);
+                                        const valueEnd = document.positionAt(templateStartOffset + prop.value.loc.end.offset);
+                                        if (prop.value.loc.end.offset - prop.value.loc.start.offset !== prop.value.content.length) {
+                                            valueStart.character++;
+                                            valueEnd.character--;
+                                        }
+                                        edits.push({
+                                            newText: "'",
+                                            range: {
+                                                start: valueStart,
+                                                end: valueStart,
+                                            },
+                                        });
+                                        edits.push({
+                                            newText: "'",
+                                            range: {
+                                                start: valueEnd,
+                                                end: valueEnd,
+                                            },
+                                        });
+                                    }
+                                    else {
+                                        const addValuePos = document.positionAt(templateStartOffset + prop.loc.end.offset);
+                                        newPosition = {
+                                            line: addValuePos.line,
+                                            character: addValuePos.character + ':'.length + '="'.length,
+                                        };
+                                        edits.push({
+                                            newText: '=""',
+                                            range: {
+                                                start: addValuePos,
+                                                end: addValuePos
+                                            },
+                                        });
+                                    }
+                                    result.push({
+                                        title: 'Add v-bind to attribute',
+                                        kind: 'refactor.rewrite.addVBind',
+                                        edit: {
+                                            changes: { [document.uri]: edits },
+                                        },
+                                        command: newPosition ? context?.commands.setSelection.create(newPosition) : undefined,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    return result;
+                },
+                transformCodeAction(item) {
+                    return item; // ignore mapping
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-toggle-v-bind-codeaction.js.map

package/lib/plugins/vue-twoslash-queries.d.ts

@@ -0,0 +1,2 @@
+import type { ServicePlugin } from '@volar/language-service';
+export declare function create(ts: typeof import('typescript')): ServicePlugin;

package/lib/plugins/vue-twoslash-queries.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const vue = require("@vue/language-core");
+const client_1 = require("@vue/typescript-plugin/lib/client");
+const twoslashReg = /<!--\s*\^\?\s*-->/g;
+function create(ts) {
+    return {
+        name: 'vue-twoslash-queries',
+        create(context) {
+            return {
+                async provideInlayHints(document, range) {
+                    const [virtualCode, sourceFile] = context.documents.getVirtualCodeByUri(document.uri);
+                    if (!(sourceFile?.generated?.code instanceof vue.VueGeneratedCode) || virtualCode?.id !== 'template')
+                        return;
+                    const hoverOffsets = [];
+                    const inlayHints = [];
+                    for (const pointer of document.getText(range).matchAll(twoslashReg)) {
+                        const offset = pointer.index + pointer[0].indexOf('^?') + document.offsetAt(range.start);
+                        const position = document.positionAt(offset);
+                        hoverOffsets.push([position, document.offsetAt({
+                                line: position.line - 1,
+                                character: position.character,
+                            })]);
+                    }
+                    for (const [pointerPosition, hoverOffset] of hoverOffsets) {
+                        for (const [_1, [_2, map]] of context.language.files.getMaps(virtualCode)) {
+                            for (const [sourceOffset] of map.getSourceOffsets(hoverOffset)) {
+                                const quickInfo = await (0, client_1.getQuickInfoAtPosition)(sourceFile.generated.code.fileName, sourceOffset);
+                                if (quickInfo) {
+                                    inlayHints.push({
+                                        position: { line: pointerPosition.line, character: pointerPosition.character + 2 },
+                                        label: ts.displayPartsToString(quickInfo.displayParts),
+                                        paddingLeft: true,
+                                        paddingRight: false,
+                                    });
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+                    }
+                    return inlayHints;
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-twoslash-queries.js.map

package/lib/plugins/vue-visualize-hidden-callback-param.d.ts

@@ -0,0 +1,2 @@
+import type { ServicePlugin } from '../types';
+export declare function create(): ServicePlugin;

package/lib/plugins/vue-visualize-hidden-callback-param.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+function create() {
+    return {
+        name: 'vue-inlay-hints-hidden-callback-param',
+        create(context) {
+            return {
+                async provideInlayHints(document, range) {
+                    const settings = {};
+                    const result = [];
+                    const [vitualFile] = context.documents.getVirtualCodeByUri(document.uri);
+                    if (vitualFile) {
+                        const start = document.offsetAt(range.start);
+                        const end = document.offsetAt(range.end);
+                        for (const mapping of vitualFile.mappings) {
+                            const hint = mapping.data.__hint;
+                            if (mapping.generatedOffsets[0] >= start
+                                && mapping.generatedOffsets[mapping.generatedOffsets.length - 1] + mapping.lengths[mapping.lengths.length - 1] <= end
+                                && hint) {
+                                settings[hint.setting] ??= await context.env.getConfiguration?.(hint.setting) ?? false;
+                                if (!settings[hint.setting])
+                                    continue;
+                                result.push({
+                                    label: hint.label,
+                                    paddingRight: hint.paddingRight,
+                                    paddingLeft: hint.paddingLeft,
+                                    position: document.positionAt(mapping.generatedOffsets[0]),
+                                    kind: 2,
+                                    tooltip: {
+                                        kind: 'markdown',
+                                        value: hint.tooltip,
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    return result;
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-visualize-hidden-callback-param.js.map

package/lib/types.d.ts

@@ -0,0 +1,10 @@
+export declare enum TagNameCasing {
+    Kebab = 0,
+    Pascal = 1
+}
+export declare enum AttrNameCasing {
+    Kebab = 0,
+    Camel = 1
+}
+export * from '@volar/language-service/lib/types';
+export * from '@vue/language-core/lib/types';

package/lib/types.js

@@ -0,0 +1,31 @@
+"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 });
+exports.AttrNameCasing = exports.TagNameCasing = void 0;
+var TagNameCasing;
+(function (TagNameCasing) {
+    TagNameCasing[TagNameCasing["Kebab"] = 0] = "Kebab";
+    TagNameCasing[TagNameCasing["Pascal"] = 1] = "Pascal";
+})(TagNameCasing || (exports.TagNameCasing = TagNameCasing = {}));
+var AttrNameCasing;
+(function (AttrNameCasing) {
+    AttrNameCasing[AttrNameCasing["Kebab"] = 0] = "Kebab";
+    AttrNameCasing[AttrNameCasing["Camel"] = 1] = "Camel";
+})(AttrNameCasing || (exports.AttrNameCasing = AttrNameCasing = {}));
+// only export types of depend packages
+__exportStar(require("@volar/language-service/lib/types"), exports);
+__exportStar(require("@vue/language-core/lib/types"), exports);
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "@vue/language-service",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"license": "MIT",
 	"files": [
 		"data",
-		"out/**/*.js",
-		"out/**/*.d.ts"
+		"**/*.js",
+		"**/*.d.ts"
 	],
 	"repository": {
 		"type": "git",
@@ -20,9 +20,9 @@
 		"@volar/language-service": "~2.1.0",
 		"@volar/typescript": "~2.1.0",
 		"@vue/compiler-dom": "^3.4.0",
-		"@vue/language-core": "2.0.0",
+		"@vue/language-core": "2.0.1",
 		"@vue/shared": "^3.4.0",
-		"@vue/typescript-plugin": "2.0.0",
+		"@vue/typescript-plugin": "2.0.1",
 		"computeds": "^0.0.1",
 		"path-browserify": "^1.0.1",
 		"volar-service-css": "0.0.31",
@@ -43,5 +43,5 @@
 		"vscode-languageserver-protocol": "^3.17.5",
 		"vscode-uri": "^3.0.8"
 	},
-	"gitHead": "aa47e5a7d8a6dae62cc80dbdb5db6a9bfa4f8715"
+	"gitHead": "adedfd0983c910370d080e955702cca7d2275420"
 }