@vue/language-core 3.2.5 → 3.2.7

package/index.js

@@ -50,7 +50,7 @@ __exportStar(require("./lib/utils/parseSfc"), exports);
 __exportStar(require("./lib/utils/shared"), exports);
 __exportStar(require("./lib/virtualCode"), exports);
 exports.names = __importStar(require("./lib/codegen/names"));
-const vue_tsx_1 = require("./lib/plugins/vue-tsx");
+var vue_tsx_1 = require("./lib/plugins/vue-tsx");
 Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });
 __exportStar(require("@volar/language-core"), exports);
 //# sourceMappingURL=index.js.map

package/lib/codegen/codeFeatures.d.ts

@@ -1,20 +1,86 @@
 import type { VueCodeInformation } from '../types';
-export declare const codeFeatures: {
-    all: VueCodeInformation;
-    importCompletionOnly: VueCodeInformation;
-    verification: VueCodeInformation;
-    completion: VueCodeInformation;
-    withoutCompletion: VueCodeInformation;
-    navigation: VueCodeInformation;
-    navigationWithoutRename: VueCodeInformation;
-    navigationAndCompletion: VueCodeInformation;
-    navigationAndVerification: VueCodeInformation;
-    withoutNavigation: VueCodeInformation;
-    semanticWithoutHighlight: VueCodeInformation;
-    withoutHighlight: VueCodeInformation;
-    withoutHighlightAndCompletion: VueCodeInformation;
-    withoutSemantic: VueCodeInformation;
-    doNotReportTs2339AndTs2551: VueCodeInformation;
-    doNotReportTs2353AndTs2561: VueCodeInformation;
-    doNotReportTs6133: VueCodeInformation;
+declare const raw: {
+    all: {
+        verification: true;
+        completion: true;
+        semantic: true;
+        navigation: true;
+    };
+    importCompletionOnly: {
+        __importCompletion: true;
+    };
+    verification: {
+        verification: true;
+    };
+    completion: {
+        completion: true;
+    };
+    withoutCompletion: {
+        verification: true;
+        semantic: true;
+        navigation: true;
+    };
+    navigation: {
+        navigation: true;
+    };
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename: () => false;
+        };
+    };
+    navigationAndCompletion: {
+        navigation: true;
+        completion: true;
+    };
+    navigationAndVerification: {
+        navigation: true;
+        verification: true;
+    };
+    withoutNavigation: {
+        verification: true;
+        completion: true;
+        semantic: true;
+    };
+    semanticWithoutHighlight: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+    };
+    withoutHighlight: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+        completion: true;
+    };
+    withoutHighlightAndCompletion: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+    };
+    withoutSemantic: {
+        verification: true;
+        navigation: true;
+        completion: true;
+    };
+    doNotReportTs2339AndTs2551: {
+        verification: {
+            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
+        };
+    };
+    doNotReportTs2353AndTs2561: {
+        verification: {
+            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
+        };
+    };
+    doNotReportTs6133: {
+        verification: {
+            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
+        };
+    };
 };
+export declare const codeFeatures: { [K in keyof typeof raw]: VueCodeInformation; };
+export {};

package/lib/codegen/style/index.d.ts

@@ -10,21 +10,21 @@ export { generate as generateStyle };
 declare function generate(options: StyleCodegenOptions): {
     generatedTypes: Set<string>;
     currentInfo: {
-        ignoreError?: boolean | undefined;
+        ignoreError?: boolean;
         expectError?: {
             token: number;
             node: import("@vue/compiler-dom").CommentNode;
-        } | undefined;
+        };
         generic?: {
             content: string;
             offset: number;
-        } | undefined;
+        };
     };
     resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
     inVFor: boolean;
     slots: {
         name: string;
-        offset?: number | undefined;
+        offset?: number;
         tagRange: [number, number];
         nodeLoc: any;
         propsVar: string;
@@ -45,7 +45,7 @@ declare function generate(options: StyleCodegenOptions): {
     singleRootElTypes: Set<string>;
     singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     addTemplateRef(name: string, typeExp: string, offset: number): void;
-    recordComponentAccess(source: string, name: string, offset?: number | undefined): void;
+    recordComponentAccess(source: string, name: string, offset?: number): void;
     scopes: Set<string>[];
     components: (() => string)[];
     declare(...varNames: string[]): void;
@@ -54,7 +54,7 @@ declare function generate(options: StyleCodegenOptions): {
     getHoistVariable(originalVar: string): string;
     generateHoistVariables(): Generator<string, void, unknown>;
     generateConditionGuards(): Generator<string, void, unknown>;
-    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").SimpleExpressionNode | import("@vue/compiler-dom").TemplateChildNode): boolean;
-    exit(): Generator<Code, any, any>;
+    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+    exit(): Generator<Code>;
     codes: Code[];
 };

package/lib/codegen/template/context.d.ts

@@ -102,21 +102,21 @@ export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenCont
 export declare function createTemplateCodegenContext(): {
     generatedTypes: Set<string>;
     readonly currentInfo: {
-        ignoreError?: boolean | undefined;
+        ignoreError?: boolean;
         expectError?: {
             token: number;
             node: CompilerDOM.CommentNode;
-        } | undefined;
+        };
         generic?: {
             content: string;
             offset: number;
-        } | undefined;
+        };
     };
     resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
     inVFor: boolean;
     slots: {
         name: string;
-        offset?: number | undefined;
+        offset?: number;
         tagRange: [number, number];
         nodeLoc: any;
         propsVar: string;
@@ -137,7 +137,7 @@ export declare function createTemplateCodegenContext(): {
     singleRootElTypes: Set<string>;
     singleRootNodes: Set<CompilerDOM.ElementNode | null>;
     addTemplateRef(name: string, typeExp: string, offset: number): void;
-    recordComponentAccess(source: string, name: string, offset?: number | undefined): void;
+    recordComponentAccess(source: string, name: string, offset?: number): void;
     scopes: Set<string>[];
     components: (() => string)[];
     declare(...varNames: string[]): void;
@@ -146,6 +146,6 @@ export declare function createTemplateCodegenContext(): {
     getHoistVariable(originalVar: string): string;
     generateHoistVariables(): Generator<string, void, unknown>;
     generateConditionGuards(): Generator<string, void, unknown>;
-    enter(node: CompilerDOM.RootNode | CompilerDOM.SimpleExpressionNode | CompilerDOM.TemplateChildNode): boolean;
-    exit(): Generator<Code, any, any>;
+    enter(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): boolean;
+    exit(): Generator<Code>;
 };

package/lib/codegen/template/index.d.ts

@@ -16,21 +16,21 @@ export { generate as generateTemplate };
 declare function generate(options: TemplateCodegenOptions): {
     generatedTypes: Set<string>;
     currentInfo: {
-        ignoreError?: boolean | undefined;
+        ignoreError?: boolean;
         expectError?: {
             token: number;
             node: import("@vue/compiler-dom").CommentNode;
-        } | undefined;
+        };
         generic?: {
             content: string;
             offset: number;
-        } | undefined;
+        };
     };
     resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
     inVFor: boolean;
     slots: {
         name: string;
-        offset?: number | undefined;
+        offset?: number;
         tagRange: [number, number];
         nodeLoc: any;
         propsVar: string;
@@ -51,7 +51,7 @@ declare function generate(options: TemplateCodegenOptions): {
     singleRootElTypes: Set<string>;
     singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     addTemplateRef(name: string, typeExp: string, offset: number): void;
-    recordComponentAccess(source: string, name: string, offset?: number | undefined): void;
+    recordComponentAccess(source: string, name: string, offset?: number): void;
     scopes: Set<string>[];
     components: (() => string)[];
     declare(...varNames: string[]): void;
@@ -60,7 +60,7 @@ declare function generate(options: TemplateCodegenOptions): {
     getHoistVariable(originalVar: string): string;
     generateHoistVariables(): Generator<string, void, unknown>;
     generateConditionGuards(): Generator<string, void, unknown>;
-    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").SimpleExpressionNode | import("@vue/compiler-dom").TemplateChildNode): boolean;
-    exit(): Generator<Code, any, any>;
+    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+    exit(): Generator<Code>;
     codes: Code[];
 };

package/lib/codegen/template/index.js

@@ -109,7 +109,11 @@ function* generateWorker(options, ctx) {
     yield* endScope();
 }
 function* generateSlotsType(options, ctx) {
-    if (options.hasDefineSlots || (!ctx.slots.length && !ctx.dynamicSlots.length)) {
+    if (options.hasDefineSlots) {
+        ctx.generatedTypes.add(names.Slots);
+        return;
+    }
+    if (!ctx.slots.length && !ctx.dynamicSlots.length) {
         return;
     }
     ctx.generatedTypes.add(names.Slots);

package/lib/compilerOptions.js

@@ -79,15 +79,11 @@ function createParsedCommandLine(ts, host, configFileName) {
     };
 }
 class CompilerOptionsResolver {
-    ts;
-    readFile;
-    options = {};
-    target;
-    typesRoot;
-    plugins = [];
     constructor(ts, readFile) {
         this.ts = ts;
         this.readFile = readFile;
+        this.options = {};
+        this.plugins = [];
     }
     addConfig(options, rootDir) {
         for (const key in options) {

package/lib/parsers/scriptRanges.d.ts

@@ -8,13 +8,13 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), sourc
         isObjectLiteral: boolean;
         options?: {
             isObjectLiteral: boolean;
-            expression: TextRange<ts.Node>;
+            expression: TextRange;
             args: TextRange<ts.ObjectLiteralExpression>;
             components: TextRange<ts.ObjectLiteralExpression> | undefined;
-            directives: TextRange<ts.Node> | undefined;
+            directives: TextRange | undefined;
             name: TextRange<ts.StringLiteral> | undefined;
             inheritAttrs: string | undefined;
-        } | undefined;
+        };
     }) | undefined;
     bindings: TextRange<ts.Node>[];
     components: TextRange<ts.Node>[];

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

@@ -6,13 +6,13 @@ export declare const tsCodegen: WeakMap<Sfc, {
             isObjectLiteral: boolean;
             options?: {
                 isObjectLiteral: boolean;
-                expression: import("../types").TextRange<import("typescript").Node>;
+                expression: import("../types").TextRange;
                 args: import("../types").TextRange<import("typescript").ObjectLiteralExpression>;
                 components: import("../types").TextRange<import("typescript").ObjectLiteralExpression> | undefined;
-                directives: import("../types").TextRange<import("typescript").Node> | undefined;
+                directives: import("../types").TextRange | undefined;
                 name: import("../types").TextRange<import("typescript").StringLiteral> | undefined;
                 inheritAttrs: string | undefined;
-            } | undefined;
+            };
         }) | undefined;
         bindings: import("../types").TextRange<import("typescript").Node>[];
         components: import("../types").TextRange<import("typescript").Node>[];
@@ -51,21 +51,21 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getGeneratedTemplate: () => {
         generatedTypes: Set<string>;
         currentInfo: {
-            ignoreError?: boolean | undefined;
+            ignoreError?: boolean;
             expectError?: {
                 token: number;
                 node: import("@vue/compiler-dom").CommentNode;
-            } | undefined;
+            };
             generic?: {
                 content: string;
                 offset: number;
-            } | undefined;
+            };
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
         inVFor: boolean;
         slots: {
             name: string;
-            offset?: number | undefined;
+            offset?: number;
             tagRange: [number, number];
             nodeLoc: any;
             propsVar: string;
@@ -86,7 +86,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         singleRootElTypes: Set<string>;
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         addTemplateRef(name: string, typeExp: string, offset: number): void;
-        recordComponentAccess(source: string, name: string, offset?: number | undefined): void;
+        recordComponentAccess(source: string, name: string, offset?: number): void;
         scopes: Set<string>[];
         components: (() => string)[];
         declare(...varNames: string[]): void;
@@ -95,8 +95,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
         getHoistVariable(originalVar: string): string;
         generateHoistVariables(): Generator<string, void, unknown>;
         generateConditionGuards(): Generator<string, void, unknown>;
-        enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").SimpleExpressionNode | import("@vue/compiler-dom").TemplateChildNode): boolean;
-        exit(): Generator<import("../types").Code, any, any>;
+        enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+        exit(): Generator<import("../types").Code>;
         codes: import("../types").Code[];
     } | undefined;
     getImportedComponents: () => Set<string>;

package/lib/types.d.ts

@@ -69,7 +69,7 @@ export interface VueCompilerOptions {
 }
 export declare const validVersions: readonly [2, 2.1, 2.2];
 export interface VueLanguagePluginReturn {
-    version: typeof validVersions[number];
+    version: (typeof validVersions)[number];
     name?: string;
     order?: number;
     requiredCompilerOptions?: string[];

package/lib/utils/shared.js

@@ -7,7 +7,7 @@ exports.getElementTagOffsets = getElementTagOffsets;
 exports.getStartEnd = getStartEnd;
 exports.getNodeText = getNodeText;
 const shared_1 = require("@vue/shared");
-const shared_2 = require("@vue/shared");
+var shared_2 = require("@vue/shared");
 Object.defineProperty(exports, "hyphenateTag", { enumerable: true, get: function () { return shared_2.hyphenate; } });
 function hyphenateAttr(str) {
     let hyphencase = (0, shared_1.hyphenate)(str);

package/lib/virtualCode/embeddedCodes.js

@@ -6,16 +6,12 @@ const alien_signals_1 = require("alien-signals");
 const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 class VueEmbeddedCode {
-    id;
-    lang;
-    content;
-    parentCodeId;
-    linkedCodeMappings = [];
-    embeddedCodes = [];
     constructor(id, lang, content) {
         this.id = id;
         this.lang = lang;
         this.content = content;
+        this.linkedCodeMappings = [];
+        this.embeddedCodes = [];
     }
 }
 exports.VueEmbeddedCode = VueEmbeddedCode;

package/lib/virtualCode/index.js

@@ -6,16 +6,6 @@ const plugins_1 = require("../plugins");
 const embeddedCodes_1 = require("./embeddedCodes");
 const ir_1 = require("./ir");
 class VueVirtualCode {
-    fileName;
-    languageId;
-    initSnapshot;
-    vueCompilerOptions;
-    id = 'main';
-    _snapshot;
-    _parsedSfcResult;
-    _ir;
-    _embeddedCodes;
-    _mappings;
     get snapshot() {
         return this._snapshot();
     }
@@ -36,6 +26,7 @@ class VueVirtualCode {
         this.languageId = languageId;
         this.initSnapshot = initSnapshot;
         this.vueCompilerOptions = vueCompilerOptions;
+        this.id = 'main';
         this._snapshot = (0, alien_signals_1.signal)(initSnapshot);
         this._parsedSfcResult = (0, alien_signals_1.computed)(lastResult => this.parseSfc(plugins, lastResult));
         this._ir = (0, ir_1.useIR)(ts, plugins, fileName, this._snapshot, () => this._parsedSfcResult()?.result);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.2.5",
+	"version": "3.2.7",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -16,17 +16,17 @@
 		"@volar/language-core": "2.4.28",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/shared": "^3.5.0",
-		"alien-signals": "^3.0.0",
+		"alien-signals": "^3.1.2",
 		"muggle-string": "^0.4.1",
 		"path-browserify": "^1.0.1",
-		"picomatch": "^4.0.2"
+		"picomatch": "^4.0.4"
 	},
 	"devDependencies": {
 		"@types/node": "^22.10.4",
-		"@types/path-browserify": "^1.0.1",
-		"@types/picomatch": "^4.0.0",
+		"@types/path-browserify": "^1.0.3",
+		"@types/picomatch": "^4.0.3",
 		"@volar/typescript": "2.4.28",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "ee5041d27940cf6f9a5150635d3b13140a9dff54"
+	"gitHead": "a7092edf12862f0db8e39bd2afbda3d54aa26506"
 }

package/types/template-helpers.d.ts

@@ -111,7 +111,7 @@ declare global {
 
 	function __VLS_vFor<T>(source: T): T extends number ? [number, number][]
 		: T extends string ? [string, number][]
-		: T extends (infer U)[] ? [U, number][]
+		: T extends readonly (infer U)[] ? [U, number][]
 		: T extends Iterable<infer V> ? [V, number][]
 		: [T[keyof T], keyof T extends string ? keyof T : `${keyof T & (string | number)}`, number][];
 	function __VLS_vSlot<S, D extends S>(slot: S, decl?: D): D extends (...args: infer P) => any ? P : any[];