@vue/language-core 3.0.0-alpha.6 → 3.0.0-beta.1

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './lib/codegen/globalTypes';
 export * from './lib/codegen/template';
+export * from './lib/codegen/utils';
 export * from './lib/languagePlugin';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';

package/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 __exportStar(require("./lib/codegen/globalTypes"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
+__exportStar(require("./lib/codegen/utils"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);
 __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);

package/lib/codegen/codeFeatures.d.ts

@@ -78,6 +78,11 @@ declare const raw: {
         };
         verification: true;
     };
+    withoutSemantic: {
+        verification: true;
+        navigation: true;
+        completion: true;
+    };
 };
 export declare const codeFeatures: { [K in keyof typeof raw]: VueCodeInformation; };
 export {};

package/lib/codegen/codeFeatures.js

@@ -66,6 +66,11 @@ const raw = {
         semantic: { shouldHighlight: () => false },
         verification: true,
     },
+    withoutSemantic: {
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
 };
 exports.codeFeatures = raw;
 //# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/globalTypes.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalTypesFileName = getGlobalTypesFileName;
 exports.generateGlobalTypes = generateGlobalTypes;
-const shared_1 = require("../utils/shared");
 function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
     return [
         lib,
@@ -62,7 +61,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 	type __VLS_FunctionalComponent<T> = (props: ${fnPropsType}, ctx?: any) => __VLS_Element & {
 		__ctx?: {
 			attrs?: any,
-			slots?: T extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : Record<string, any>,
+			slots?: T extends { $slots: infer Slots } ? Slots : Record<string, any>,
 			emit?: T extends { $emit: infer Emit } ? Emit : {},
 			props?: ${fnPropsType},
 			expose?: (exposed: T) => void,
@@ -150,9 +149,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
 	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
 		T extends new (...args: any) => any ? __VLS_FunctionalComponent<K>
-		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>${(target === 2.7
-        ? `: T extends import('${lib}').AsyncComponent ? (props: {}, ctx?: any) => any`
-        : ``)}
+		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
 		: T extends (...args: any) => any ? T
 		: __VLS_FunctionalComponent<{}>;
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];

package/lib/codegen/localTypes.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalTypesGenerator = getLocalTypesGenerator;
-const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
 function getLocalTypesGenerator(vueCompilerOptions) {
     const used = new Set();
@@ -21,7 +20,7 @@ type __VLS_WithDefaults<P, D> = {
     const WithSlots = defineHelper(`__VLS_WithSlots`, () => `
 type __VLS_WithSlots<T, S> = T & {
 	new(): {
-		${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;
+		$slots: S;
 		${vueCompilerOptions.jsxSlots ? `$props: ${PropsChildren.name}<S>;` : ''}
 	}
 };

package/lib/codegen/script/component.js

@@ -60,7 +60,7 @@ function* generateComponentSetupReturns(scriptSetupRanges) {
 }
 function* generateEmitsOption(options, scriptSetupRanges) {
     const codes = [];
-    if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+    if (scriptSetupRanges.defineModel.length) {
         codes.push({
             optionExp: `{} as __VLS_NormalizeEmits<typeof __VLS_modelEmit>`,
             typeOptionType: `__VLS_ModelEmit`,

package/lib/codegen/script/index.js

@@ -36,7 +36,7 @@ function* generateScript(options) {
         yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
     }
     if (options.sfc.script && options.scriptRanges) {
-        const { exportDefault, classBlockEnd } = options.scriptRanges;
+        const { exportDefault } = options.scriptRanges;
         const isExportRawObject = exportDefault
             && options.sfc.script.content[exportDefault.expression.start] === '{';
         if (options.sfc.scriptSetup && options.scriptSetupRanges) {
@@ -77,19 +77,6 @@ function* generateScript(options) {
             yield options.vueCompilerOptions.optionsWrapper[1];
             yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
         }
-        else if (classBlockEnd !== undefined) {
-            if (options.vueCompilerOptions.skipTemplateCodegen) {
-                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
-            }
-            else {
-                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, classBlockEnd, codeFeatures_1.codeFeatures.all);
-                yield `__VLS_template = () => {${utils_1.newLine}`;
-                const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
-                yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
-                yield `}${utils_1.endOfLine}`;
-                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, classBlockEnd, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
-            }
-        }
         else {
             yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
             yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/script.vue');

package/lib/codegen/script/scriptSetup.js

@@ -50,7 +50,7 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
         if (scriptSetupRanges.defineEmits) {
             emitTypes.push(`typeof ${scriptSetupRanges.defineEmits.name ?? '__VLS_emit'}`);
         }
-        if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+        if (scriptSetupRanges.defineModel.length) {
             emitTypes.push(`typeof __VLS_modelEmit`);
         }
         yield `return {} as {${utils_1.newLine}`
@@ -187,7 +187,7 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
         const templateRefType = arg
             ? [
                 `__VLS_TemplateRefs[`,
-                (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.all),
+                (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.withoutSemantic),
                 `]`
             ]
             : [`unknown`];
@@ -235,7 +235,6 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
     yield (0, utils_1.generateSfcBlockSection)(scriptSetup, nextStart, scriptSetup.content.length, codeFeatures_1.codeFeatures.all);
     yield* (0, index_1.generateScriptSectionPartiallyEnding)(scriptSetup.name, scriptSetup.content.length, '#3632/scriptSetup.vue');
     yield* generateMacros(options, ctx);
-    yield* generateDefineProp(options);
     if (scriptSetupRanges.defineProps?.typeArg && scriptSetupRanges.withDefaults?.arg) {
         // fix https://github.com/vuejs/language-tools/issues/1187
         yield `const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`;
@@ -276,22 +275,6 @@ function* generateMacros(options, ctx) {
         yield `}: typeof import('${options.vueCompilerOptions.lib}')${utils_1.endOfLine}`;
     }
 }
-function* generateDefineProp(options) {
-    const definePropProposalA = options.vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
-    const definePropProposalB = options.vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
-    if (definePropProposalA || definePropProposalB) {
-        yield `type __VLS_PropOptions<T> = Exclude<import('${options.vueCompilerOptions.lib}').Prop<T>, import('${options.vueCompilerOptions.lib}').PropType<T>>${utils_1.endOfLine}`;
-        if (definePropProposalA) {
-            yield `declare function defineProp<T>(name: string, options: ({ required: true } | { default: T }) & __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${utils_1.endOfLine}`;
-            yield `declare function defineProp<T>(name?: string, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${utils_1.endOfLine}`;
-        }
-        if (definePropProposalB) {
-            yield `declare function defineProp<T>(value: T | (() => T), required?: boolean, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${utils_1.endOfLine}`;
-            yield `declare function defineProp<T>(value: T | (() => T) | undefined, required: true, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${utils_1.endOfLine}`;
-            yield `declare function defineProp<T>(value?: T | (() => T), required?: boolean, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${utils_1.endOfLine}`;
-        }
-    }
-}
 function* generateDefineWithType(scriptSetup, statement, callExp, typeArg, name, defaultName, typeName) {
     if (typeArg) {
         yield [[
@@ -340,34 +323,23 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges) {
         yield `})${utils_1.endOfLine}`;
         yield `type __VLS_BuiltInPublicProps = ${options.vueCompilerOptions.target >= 3.4
             ? `import('${options.vueCompilerOptions.lib}').PublicProps`
-            : options.vueCompilerOptions.target >= 3.0
-                ? `import('${options.vueCompilerOptions.lib}').VNodeProps`
-                    + ` & import('${options.vueCompilerOptions.lib}').AllowedComponentProps`
-                    + ` & import('${options.vueCompilerOptions.lib}').ComponentCustomProps`
-                : `globalThis.JSX.IntrinsicAttributes`}`;
+            : `import('${options.vueCompilerOptions.lib}').VNodeProps`
+                + ` & import('${options.vueCompilerOptions.lib}').AllowedComponentProps`
+                + ` & import('${options.vueCompilerOptions.lib}').ComponentCustomProps`}`;
         yield utils_1.endOfLine;
         yield `type __VLS_OwnProps = `;
         yield `${ctx.localTypes.OmitKeepDiscriminatedUnion}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof __VLS_BuiltInPublicProps>`;
         yield utils_1.endOfLine;
     }
-    if (scriptSetupRanges.defineProp.length) {
+    if (scriptSetupRanges.defineModel.length) {
         yield `const __VLS_defaults = {${utils_1.newLine}`;
-        for (const defineProp of scriptSetupRanges.defineProp) {
-            if (!defineProp.defaultValue) {
-                continue;
-            }
-            const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
-            if (defineProp.name || defineProp.isModel) {
-                yield `'${propName}'`;
-            }
-            else if (defineProp.localName) {
-                yield localName;
-            }
-            else {
+        for (const defineModel of scriptSetupRanges.defineModel) {
+            if (!defineModel.defaultValue) {
                 continue;
             }
-            yield `: `;
-            yield getRangeText(scriptSetup, defineProp.defaultValue);
+            const [propName] = getPropAndLocalName(scriptSetup, defineModel);
+            yield `'${propName}': `;
+            yield getRangeText(scriptSetup, defineModel.defaultValue);
             yield `,${utils_1.newLine}`;
         }
         yield `}${utils_1.endOfLine}`;
@@ -387,38 +359,30 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges) {
         ctx.generatedPropsType = true;
         yield `__VLS_Props`;
     }
-    if (scriptSetupRanges.defineProp.length) {
+    if (scriptSetupRanges.defineModel.length) {
         if (ctx.generatedPropsType) {
             yield ` & `;
         }
         ctx.generatedPropsType = true;
         yield `{${utils_1.newLine}`;
-        for (const defineProp of scriptSetupRanges.defineProp) {
-            const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
-            if (defineProp.comments) {
-                yield scriptSetup.content.slice(defineProp.comments.start, defineProp.comments.end);
+        for (const defineModel of scriptSetupRanges.defineModel) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
+            if (defineModel.comments) {
+                yield scriptSetup.content.slice(defineModel.comments.start, defineModel.comments.end);
                 yield utils_1.newLine;
             }
-            if (defineProp.isModel && !defineProp.name) {
-                yield propName;
-            }
-            else if (defineProp.name) {
-                yield* (0, camelized_1.generateCamelized)(getRangeText(scriptSetup, defineProp.name), scriptSetup.name, defineProp.name.start, codeFeatures_1.codeFeatures.navigation);
-            }
-            else if (defineProp.localName) {
-                yield (0, utils_1.generateSfcBlockSection)(scriptSetup, defineProp.localName.start, defineProp.localName.end, codeFeatures_1.codeFeatures.navigation);
+            if (defineModel.name) {
+                yield* (0, camelized_1.generateCamelized)(getRangeText(scriptSetup, defineModel.name), scriptSetup.name, defineModel.name.start, codeFeatures_1.codeFeatures.navigation);
             }
             else {
-                continue;
+                yield propName;
             }
-            yield defineProp.required
-                ? `: `
-                : `?: `;
-            yield* generateDefinePropType(scriptSetup, propName, localName, defineProp);
+            yield defineModel.required ? `: ` : `?: `;
+            yield* generateDefineModelType(scriptSetup, propName, localName, defineModel);
             yield `,${utils_1.newLine}`;
-            if (defineProp.modifierType) {
-                const modifierName = `${defineProp.name ? propName : 'model'}Modifiers`;
-                const modifierType = getRangeText(scriptSetup, defineProp.modifierType);
+            if (defineModel.modifierType) {
+                const modifierName = `${defineModel.name ? propName : 'model'}Modifiers`;
+                const modifierType = getRangeText(scriptSetup, defineModel.modifierType);
                 yield `'${modifierName}'?: Partial<Record<${modifierType}, true>>,${utils_1.newLine}`;
             }
         }
@@ -430,13 +394,12 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges) {
     yield utils_1.endOfLine;
 }
 function* generateModelEmit(scriptSetup, scriptSetupRanges) {
-    const defineModels = scriptSetupRanges.defineProp.filter(p => p.isModel);
-    if (defineModels.length) {
+    if (scriptSetupRanges.defineModel.length) {
         yield `type __VLS_ModelEmit = {${utils_1.newLine}`;
-        for (const defineModel of defineModels) {
+        for (const defineModel of scriptSetupRanges.defineModel) {
             const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
             yield `'update:${propName}': [value: `;
-            yield* generateDefinePropType(scriptSetup, propName, localName, defineModel);
+            yield* generateDefineModelType(scriptSetup, propName, localName, defineModel);
             if (!defineModel.required && !defineModel.defaultValue) {
                 yield ` | undefined`;
             }
@@ -446,32 +409,30 @@ function* generateModelEmit(scriptSetup, scriptSetupRanges) {
         yield `const __VLS_modelEmit = defineEmits<__VLS_ModelEmit>()${utils_1.endOfLine}`;
     }
 }
-function* generateDefinePropType(scriptSetup, propName, localName, defineProp) {
-    if (defineProp.type) {
-        // Infer from defineProp<T>
-        yield getRangeText(scriptSetup, defineProp.type);
+function* generateDefineModelType(scriptSetup, propName, localName, defineModel) {
+    if (defineModel.type) {
+        // Infer from defineModel<T>
+        yield getRangeText(scriptSetup, defineModel.type);
     }
-    else if (defineProp.runtimeType && localName) {
+    else if (defineModel.runtimeType && localName) {
         // Infer from actual prop declaration code 
         yield `typeof ${localName}['value']`;
     }
-    else if (defineProp.defaultValue && propName) {
-        // Infer from defineProp({default: T})
+    else if (defineModel.defaultValue && propName) {
+        // Infer from defineModel({default: T})
         yield `typeof __VLS_defaults['${propName}']`;
     }
     else {
         yield `any`;
     }
 }
-function getPropAndLocalName(scriptSetup, defineProp) {
-    const localName = defineProp.localName
-        ? getRangeText(scriptSetup, defineProp.localName)
+function getPropAndLocalName(scriptSetup, defineModel) {
+    const localName = defineModel.localName
+        ? getRangeText(scriptSetup, defineModel.localName)
         : undefined;
-    const propName = defineProp.name
-        ? (0, shared_1.camelize)(getRangeText(scriptSetup, defineProp.name).slice(1, -1))
-        : defineProp.isModel
-            ? 'modelValue'
-            : localName;
+    const propName = defineModel.name
+        ? (0, shared_1.camelize)(getRangeText(scriptSetup, defineModel.name).slice(1, -1))
+        : 'modelValue';
     return [propName, localName];
 }
 function getRangeText(scriptSetup, range) {

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

@@ -0,0 +1,2 @@
+import type { Code, Sfc } from '../../types';
+export declare function generateStyleImports(style: Sfc['styles'][number]): Generator<Code>;

package/lib/codegen/style/imports.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleImports = generateStyleImports;
+const utils_1 = require("../utils");
+const wrapWith_1 = require("../utils/wrapWith");
+function* generateStyleImports(style) {
+    const features = {
+        navigation: true,
+        verification: true
+    };
+    if (typeof style.src === 'object') {
+        yield `${utils_1.newLine} & typeof import(`;
+        yield* (0, wrapWith_1.wrapWith)(style.src.offset, style.src.offset + style.src.text.length, 'main', features, `'`, [style.src.text, 'main', style.src.offset, utils_1.combineLastMapping], `'`);
+        yield `).default`;
+    }
+    for (const { text, offset } of style.imports) {
+        yield `${utils_1.newLine} & typeof import('`;
+        yield [
+            text,
+            style.name,
+            offset,
+            features
+        ];
+        yield `').default`;
+    }
+}
+//# sourceMappingURL=imports.js.map

package/lib/codegen/style/modules.js

@@ -4,6 +4,7 @@ exports.generateStyleModules = generateStyleModules;
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const classProperty_1 = require("./classProperty");
+const imports_1 = require("./imports");
 function* generateStyleModules(options) {
     const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
     if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
@@ -20,10 +21,17 @@ function* generateStyleModules(options) {
                 text,
                 'main',
                 offset,
-                codeFeatures_1.codeFeatures.withoutHighlight
+                codeFeatures_1.codeFeatures.navigation,
             ];
         }
-        yield `: Record<string, string> & __VLS_PrettifyGlobal<{}`;
+        yield `: `;
+        if (!options.vueCompilerOptions.strictCssModules) {
+            yield `Record<string, string> & `;
+        }
+        yield `__VLS_PrettifyGlobal<{}`;
+        if (options.vueCompilerOptions.resolveStyleImports) {
+            yield* (0, imports_1.generateStyleImports)(style);
+        }
         for (const className of style.classNames) {
             yield* (0, classProperty_1.generateClassProperty)(i, className.text, className.offset, 'string');
         }

package/lib/codegen/style/scopedClasses.js

@@ -3,17 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleScopedClasses = generateStyleScopedClasses;
 const utils_1 = require("../utils");
 const classProperty_1 = require("./classProperty");
+const imports_1 = require("./imports");
 function* generateStyleScopedClasses(options, ctx) {
-    const option = options.vueCompilerOptions.experimentalResolveStyleCssClasses;
+    const option = options.vueCompilerOptions.resolveStyleClassNames;
     const styles = options.sfc.styles
         .map((style, i) => [style, i])
-        .filter(([style]) => option === 'always' || (option === 'scoped' && style.scoped));
+        .filter(([style]) => option === true || (option === 'scoped' && style.scoped));
     if (!styles.length) {
         return;
     }
     const firstClasses = new Set();
     yield `type __VLS_StyleScopedClasses = {}`;
     for (const [style, i] of styles) {
+        if (options.vueCompilerOptions.resolveStyleImports) {
+            yield* (0, imports_1.generateStyleImports)(style);
+        }
         for (const className of style.classNames) {
             if (firstClasses.has(className.text)) {
                 ctx.scopedClasses.push({

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

@@ -129,6 +129,7 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         withoutHighlightAndNavigation: VueCodeInformation;
         withoutHighlightAndCompletion: VueCodeInformation;
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
+        withoutSemantic: VueCodeInformation;
     };
     resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
     inVFor: boolean;

package/lib/codegen/template/element.js

@@ -103,9 +103,7 @@ function* generateComponent(options, ctx, node) {
     else if (!isComponentTag) {
         yield `const ${componentOriginalVar} = ({} as __VLS_WithComponent<'${getCanonicalComponentName(node.tag)}', __VLS_LocalComponents, `;
         if (options.selfComponentName && possibleOriginalNames.includes(options.selfComponentName)) {
-            yield `typeof __VLS_self & (new () => { `
-                + (0, shared_2.getSlotsPropertyName)(options.vueCompilerOptions.target)
-                + `: __VLS_Slots }), `;
+            yield `typeof __VLS_self & (new () => { $slots: __VLS_Slots }), `;
         }
         else {
             yield `void, `;

package/lib/codegen/template/elementProps.js

@@ -111,11 +111,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             }
         }
         else if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
-            if (options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern))
-                // Vue 2 Transition doesn't support "persisted" property but `@vue/compiler-dom` always adds it (#3881)
-                || (options.vueCompilerOptions.target < 3
-                    && prop.name === 'persisted'
-                    && node.tag.toLowerCase() === 'transition')) {
+            if (options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern))) {
                 continue;
             }
             const shouldSpread = prop.name === 'style' || prop.name === 'class';
@@ -272,6 +268,6 @@ function getModelPropName(node, vueCompilerOptions) {
             }
         }
     }
-    return vueCompilerOptions.target < 3 ? 'value' : 'modelValue';
+    return 'modelValue';
 }
 //# sourceMappingURL=elementProps.js.map

package/lib/codegen/template/index.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generateTemplate;
 exports.forEachElementNode = forEachElementNode;
 const CompilerDOM = require("@vue/compiler-dom");
-const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
 const context_1 = require("./context");
@@ -18,9 +17,8 @@ function* generateTemplate(options) {
     if (options.propsAssignName) {
         ctx.addLocalVariable(options.propsAssignName);
     }
-    const slotsPropertyName = (0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target);
     if (options.vueCompilerOptions.inferTemplateDollarSlots) {
-        ctx.dollarVars.add(slotsPropertyName);
+        ctx.dollarVars.add('$slots');
     }
     if (options.vueCompilerOptions.inferTemplateDollarAttrs) {
         ctx.dollarVars.add('$attrs');
@@ -37,7 +35,7 @@ function* generateTemplate(options) {
     yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(ctx);
     yield* ctx.generateHoistVariables();
     const speicalTypes = [
-        [slotsPropertyName, yield* generateSlots(options, ctx)],
+        ['$slots', yield* generateSlots(options, ctx)],
         ['$attrs', yield* generateInheritedAttrs(options, ctx)],
         ['$refs', yield* generateTemplateRefs(options, ctx)],
         ['$el', yield* generateRootEl(ctx)]

package/lib/codegen/template/interpolation.js

@@ -114,7 +114,9 @@ function* generateVar(templateRefNames, ctx, code, offset, curVar) {
         if (ctx.dollarVars.has(curVar.text)) {
             yield [`__VLS_dollars.`, undefined];
         }
-        yield [`__VLS_ctx.`, undefined];
+        else {
+            yield [`__VLS_ctx.`, undefined];
+        }
         yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
     }
 }

package/lib/languagePlugin.js

@@ -6,7 +6,6 @@ exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
-const CompilerVue2 = require("./utils/vue2TemplateCompiler");
 const vueFile_1 = require("./virtualFile/vueFile");
 const fileRegistries = [];
 function getVueFileRegistry(key, plugins) {
@@ -38,12 +37,7 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
 function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
     const pluginContext = {
         modules: {
-            '@vue/compiler-dom': vueCompilerOptions.target < 3
-                ? {
-                    ...CompilerDOM,
-                    compile: CompilerVue2.compile,
-                }
-                : CompilerDOM,
+            '@vue/compiler-dom': CompilerDOM,
             typescript: ts,
         },
         compilerOptions,

package/lib/parsers/scriptRanges.d.ts

@@ -2,18 +2,17 @@ import type * as ts from 'typescript';
 import type { TextRange } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
-export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
+export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean): {
     exportDefault: (TextRange & {
         expression: TextRange;
         args: TextRange;
-        argsNode: ts.ObjectLiteralExpression | undefined;
+        argsNode: ts.ObjectLiteralExpression;
         componentsOption: TextRange | undefined;
         componentsOptionNode: ts.ObjectLiteralExpression | undefined;
         directivesOption: TextRange | undefined;
         nameOption: TextRange | undefined;
         inheritAttrsOption: string | undefined;
     }) | undefined;
-    classBlockEnd: number | undefined;
     bindings: {
         range: TextRange;
         moduleName?: string;

package/lib/parsers/scriptRanges.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
 const shared_1 = require("../utils/shared");
 const scriptSetupRanges_1 = require("./scriptSetupRanges");
-function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
+function parseScriptRanges(ts, ast, hasScriptSetup) {
     let exportDefault;
-    let classBlockEnd;
     const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
     ts.forEachChild(ast, raw => {
         if (ts.isExportAssignment(raw)) {
@@ -49,24 +48,18 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                     ..._getStartEnd(raw),
                     expression: _getStartEnd(node.expression),
                     args: _getStartEnd(obj),
-                    argsNode: withNode ? obj : undefined,
+                    argsNode: obj,
                     componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
-                    componentsOptionNode: withNode ? componentsOptionNode : undefined,
+                    componentsOptionNode,
                     directivesOption: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
                     nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
                     inheritAttrsOption,
                 };
             }
         }
-        if (ts.isClassDeclaration(raw)
-            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)
-            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
-            classBlockEnd = raw.end - 1;
-        }
     });
     return {
         exportDefault,
-        classBlockEnd,
         bindings,
     };
     function _getStartEnd(node) {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -6,7 +6,7 @@ type CallExpressionRange = {
     arg?: TextRange;
     typeArg?: TextRange;
 };
-type DefineProp = {
+type DefineModel = {
     localName?: TextRange;
     name?: TextRange;
     type?: TextRange;
@@ -14,7 +14,6 @@ type DefineProp = {
     runtimeType?: TextRange;
     defaultValue?: TextRange;
     required?: boolean;
-    isModel?: boolean;
     comments?: TextRange;
     argNode?: ts.Expression;
 };
@@ -55,7 +54,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         isDefaultImport?: boolean;
         isNamespace?: boolean;
     }[];
-    defineProp: DefineProp[];
+    defineModel: DefineModel[];
     defineProps: DefineProps | undefined;
     withDefaults: WithDefaults | undefined;
     defineEmits: DefineEmits | undefined;
@@ -73,4 +72,5 @@ export declare function parseBindingRanges(ts: typeof import('typescript'), ast:
     isDefaultImport?: boolean;
     isNamespace?: boolean;
 }[];
+export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, ast: ts.SourceFile): TextRange[];
 export {};

package/lib/parsers/scriptSetupRanges.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
 exports.parseBindingRanges = parseBindingRanges;
+exports.findBindingVars = findBindingVars;
 const utils_1 = require("../codegen/utils");
 const shared_1 = require("../utils/shared");
 const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
-    const defineProp = [];
+    const defineModel = [];
     let defineProps;
     let withDefaults;
     let defineEmits;
@@ -17,8 +18,6 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const useCssModule = [];
     const useSlots = [];
     const useTemplateRef = [];
-    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
-    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
     const text = ast.text;
     const leadingCommentRanges = ts.getLeadingCommentRanges(text, 0)?.reverse() ?? [];
     const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckReg.test(text.slice(range.pos, range.end)))?.end ?? 0;
@@ -26,24 +25,27 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
     ts.forEachChild(ast, node => {
-        const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node))
-            && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
-        if (!foundNonImportExportNode
-            && !ts.isImportDeclaration(node)
-            && !isTypeExport
-            && !ts.isEmptyStatement(node)
+        if (foundNonImportExportNode
+            || ts.isImportDeclaration(node)
+            || ts.isExportDeclaration(node)
+            || ts.isEmptyStatement(node)
             // fix https://github.com/vuejs/language-tools/issues/1223
-            && !ts.isImportEqualsDeclaration(node)) {
-            const commentRanges = ts.getLeadingCommentRanges(text, node.pos);
-            if (commentRanges?.length) {
-                const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
-                importSectionEndOffset = commentRange.pos;
-            }
-            else {
-                importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, ast).start;
-            }
-            foundNonImportExportNode = true;
+            || ts.isImportEqualsDeclaration(node)) {
+            return;
+        }
+        if ((ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node))
+            && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)) {
+            return;
+        }
+        const commentRanges = ts.getLeadingCommentRanges(text, node.pos);
+        if (commentRanges?.length) {
+            const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
+            importSectionEndOffset = commentRange.pos;
+        }
+        else {
+            importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, ast).start;
         }
+        foundNonImportExportNode = true;
     });
     ts.forEachChild(ast, node => visitNode(node, [ast]));
     const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
@@ -55,7 +57,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
-        defineProp,
+        defineModel,
         defineProps,
         withDefaults,
         defineEmits,
@@ -72,8 +74,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         if (ts.isCallExpression(node)
             && ts.isIdentifier(node.expression)) {
             const callText = _getNodeText(node.expression);
-            const isDefineModel = vueCompilerOptions.macros.defineModel.includes(callText);
-            if (isDefineModel || callText === 'defineProp') {
+            if (vueCompilerOptions.macros.defineModel.includes(callText)) {
                 let localName;
                 let propName;
                 let options;
@@ -82,8 +83,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 let runtimeType;
                 let defaultValue;
                 let required = false;
-                if (ts.isVariableDeclaration(parent) &&
-                    ts.isIdentifier(parent.name)) {
+                if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
                     localName = _getStartEnd(parent.name);
                 }
                 if (node.typeArguments) {
@@ -94,39 +94,16 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                         modifierType = _getStartEnd(node.typeArguments[1]);
                     }
                 }
-                if (isDefineModel) {
-                    if (node.arguments.length >= 2) {
-                        propName = node.arguments[0];
-                        options = node.arguments[1];
-                    }
-                    else if (node.arguments.length >= 1) {
-                        if (ts.isStringLiteralLike(node.arguments[0])) {
-                            propName = node.arguments[0];
-                        }
-                        else {
-                            options = node.arguments[0];
-                        }
-                    }
+                if (node.arguments.length >= 2) {
+                    propName = node.arguments[0];
+                    options = node.arguments[1];
                 }
-                else if (definePropProposalA) {
-                    if (node.arguments.length >= 2) {
-                        options = node.arguments[1];
-                    }
-                    if (node.arguments.length >= 1) {
+                else if (node.arguments.length >= 1) {
+                    if (ts.isStringLiteralLike(node.arguments[0])) {
                         propName = node.arguments[0];
                     }
-                }
-                else if (definePropProposalB) {
-                    if (node.arguments.length >= 3) {
-                        options = node.arguments[2];
-                    }
-                    if (node.arguments.length >= 2) {
-                        if (node.arguments[1].kind === ts.SyntaxKind.TrueKeyword) {
-                            required = true;
-                        }
-                    }
-                    if (node.arguments.length >= 1) {
-                        defaultValue = _getStartEnd(node.arguments[0]);
+                    else {
+                        options = node.arguments[0];
                     }
                 }
                 if (options && ts.isObjectLiteralExpression(options)) {
@@ -150,7 +127,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 if (propName && ts.isStringLiteralLike(propName)) {
                     name = _getStartEnd(propName);
                 }
-                defineProp.push({
+                defineModel.push({
                     localName,
                     name,
                     type,
@@ -158,7 +135,6 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     runtimeType,
                     defaultValue,
                     required,
-                    isModel: isDefineModel,
                     comments: getClosestMultiLineCommentRange(ts, node, parents, ast),
                     argNode: options,
                 });

package/lib/plugins/file-md.js

@@ -4,6 +4,7 @@ const language_core_1 = require("@volar/language-core");
 const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 const parseSfc_1 = require("../utils/parseSfc");
+const frontmatterReg = /^---[\s\S]*?\n---(?:\r?\n|$)/;
 const codeblockReg = /(`{3,})[\s\S]+?\1/g;
 const inlineCodeblockReg = /`[^\n`]+?`/g;
 const latexBlockReg = /(\${2,})[\s\S]+?\1/g;
@@ -28,6 +29,8 @@ const plugin = ({ vueCompilerOptions }) => {
                 return;
             }
             content = content
+                // frontmatter
+                .replace(frontmatterReg, match => ' '.repeat(match.length))
                 // code block
                 .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
                 // inline code block

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

@@ -4,14 +4,13 @@ export declare const tsCodegen: WeakMap<Sfc, {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
-            argsNode: import("typescript").ObjectLiteralExpression | undefined;
+            argsNode: import("typescript").ObjectLiteralExpression;
             componentsOption: import("../types").TextRange | undefined;
             componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
             directivesOption: import("../types").TextRange | undefined;
             nameOption: import("../types").TextRange | undefined;
             inheritAttrsOption: string | undefined;
         }) | undefined;
-        classBlockEnd: number | undefined;
         bindings: {
             range: import("../types").TextRange;
             moduleName?: string;
@@ -28,7 +27,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             isDefaultImport?: boolean;
             isNamespace?: boolean;
         }[];
-        defineProp: {
+        defineModel: {
             localName?: import("../types").TextRange;
             name?: import("../types").TextRange;
             type?: import("../types").TextRange;
@@ -36,7 +35,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             runtimeType?: import("../types").TextRange;
             defaultValue?: import("../types").TextRange;
             required?: boolean;
-            isModel?: boolean;
             comments?: import("../types").TextRange;
             argNode?: import("typescript").Expression;
         }[];
@@ -166,6 +164,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             withoutHighlightAndNavigation: import("../types").VueCodeInformation;
             withoutHighlightAndCompletion: import("../types").VueCodeInformation;
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
+            withoutSemantic: import("../types").VueCodeInformation;
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
         inVFor: boolean;

package/lib/plugins/vue-tsx.js

@@ -81,7 +81,7 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
         return ctx.vueCompilerOptions;
     });
     const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script && validLangs.has(sfc.script.lang)
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup, false)
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup)
         : undefined);
     const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup && validLangs.has(sfc.scriptSetup.lang)
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())

package/lib/types.d.ts

@@ -8,7 +8,7 @@ export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
     strictTemplates?: boolean;
-    target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
+    target?: 'auto' | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
@@ -25,6 +25,7 @@ export interface VueCompilerOptions {
     jsxSlots: boolean;
     strictSlotChildren: boolean;
     strictVModel: boolean;
+    strictCssModules: boolean;
     checkUnknownProps: boolean;
     checkUnknownEvents: boolean;
     checkUnknownDirectives: boolean;
@@ -37,6 +38,8 @@ export interface VueCompilerOptions {
     inferTemplateDollarSlots: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
+    resolveStyleImports: boolean;
+    resolveStyleClassNames: boolean | 'scoped';
     fallthroughComponentNames: string[];
     dataAttributes: string[];
     htmlAttributes: string[];
@@ -57,8 +60,6 @@ export interface VueCompilerOptions {
         useTemplateRef: string[];
     };
     plugins: VueLanguagePlugin[];
-    experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
-    experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
     __setupedGlobalTypes?: true | {
         absolutePath: string;
@@ -133,8 +134,13 @@ export interface Sfc {
         ast: ts.SourceFile;
     } | undefined;
     styles: readonly (SfcBlock & {
+        src: SfcBlockAttr | undefined;
+        module: SfcBlockAttr | undefined;
         scoped: boolean;
-        module?: SfcBlockAttr | undefined;
+        imports: {
+            text: string;
+            offset: number;
+        }[];
         cssVars: {
             text: string;
             offset: number;

package/lib/utils/parseCssImports.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssImports(css: string): Generator<{
+    text: string;
+    offset: number;
+}, void, unknown>;

package/lib/utils/parseCssImports.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssImports = parseCssImports;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith('\'') || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+//# sourceMappingURL=parseCssImports.js.map

package/lib/utils/shared.d.ts

@@ -2,6 +2,5 @@ import type * as ts from 'typescript';
 import type { TextRange } from '../types';
 export { hyphenate as hyphenateTag } from '@vue/shared';
 export declare function hyphenateAttr(str: string): string;
-export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";
 export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
 export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;

package/lib/utils/shared.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hyphenateTag = void 0;
 exports.hyphenateAttr = hyphenateAttr;
-exports.getSlotsPropertyName = getSlotsPropertyName;
 exports.getStartEnd = getStartEnd;
 exports.getNodeText = getNodeText;
 const shared_1 = require("@vue/shared");
@@ -16,9 +15,6 @@ function hyphenateAttr(str) {
     }
     return hyphencase;
 }
-function getSlotsPropertyName(vueVersion) {
-    return vueVersion < 3 ? '$scopedSlots' : '$slots';
-}
 function getStartEnd(ts, node, ast) {
     return {
         start: ts.getTokenPosOfNode(node, ast),

package/lib/utils/ts.js

@@ -131,7 +131,7 @@ class CompilerOptionsResolver {
                     break;
                 case 'plugins':
                     this.plugins = (options.plugins ?? [])
-                        .map((pluginPath) => {
+                        .flatMap((pluginPath) => {
                         try {
                             const resolvedPath = resolvePath(pluginPath, rootDir);
                             if (resolvedPath) {
@@ -219,6 +219,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         jsxSlots: false,
         strictSlotChildren: strictTemplates,
         strictVModel: strictTemplates,
+        strictCssModules: false,
         checkUnknownProps: strictTemplates,
         checkUnknownEvents: strictTemplates,
         checkUnknownDirectives: strictTemplates,
@@ -231,6 +232,8 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         inferTemplateDollarSlots: false,
         skipTemplateCodegen: false,
         fallthroughAttributes: false,
+        resolveStyleImports: false,
+        resolveStyleClassNames: 'scoped',
         fallthroughComponentNames: [
             'Transition',
             'KeepAlive',
@@ -239,9 +242,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         ],
         dataAttributes: [],
         htmlAttributes: ['aria-*'],
-        optionsWrapper: target >= 2.7
-            ? [`(await import('${lib}')).defineComponent(`, `)`]
-            : [`(await import('${lib}')).default.extend(`, `)`],
+        optionsWrapper: [`(await import('${lib}')).defineComponent(`, `)`],
         macros: {
             defineProps: ['defineProps'],
             defineSlots: ['defineSlots'],
@@ -258,8 +259,6 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
             useTemplateRef: ['useTemplateRef', 'templateRef'],
         },
         plugins: [],
-        experimentalDefinePropProposal: false,
-        experimentalResolveStyleCssClasses: 'scoped',
         experimentalModelPropName: {
             '': {
                 input: true

package/lib/virtualFile/computedSfc.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.computedSfc = computedSfc;
 const alien_signals_1 = require("alien-signals");
 const parseCssClassNames_1 = require("../utils/parseCssClassNames");
+const parseCssImports_1 = require("../utils/parseCssImports");
 const parseCssVars_1 = require("../utils/parseCssVars");
 const signals_1 = require("../utils/signals");
 function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     const getUntrackedSnapshot = () => {
-        (0, alien_signals_1.pauseTracking)();
+        const pausedSub = (0, alien_signals_1.setCurrentSub)(undefined);
         const res = getSnapshot();
-        (0, alien_signals_1.resumeTracking)();
+        (0, alien_signals_1.setCurrentSub)(pausedSub);
         return res;
     };
     const getContent = (0, alien_signals_1.computed)(() => {
@@ -86,13 +87,17 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     });
     const styles = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.styles ?? []), (getBlock, i) => {
         const base = computedSfcBlock('style_' + i, 'css', getBlock);
+        const getSrc = computedAttrValue('__src', base, getBlock);
         const getModule = computedAttrValue('__module', base, getBlock);
         const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
+        const getImports = (0, signals_1.computedItems)(() => [...(0, parseCssImports_1.parseCssImports)(base.content)], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
         const getCssVars = (0, signals_1.computedItems)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
         const getClassNames = (0, signals_1.computedItems)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
         return () => mergeObject(base, {
+            get src() { return getSrc(); },
             get module() { return getModule(); },
             get scoped() { return getScoped(); },
+            get imports() { return getImports(); },
             get cssVars() { return getCssVars(); },
             get classNames() { return getClassNames(); },
         });
@@ -127,9 +132,9 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             if (cache?.plugin.updateSFCTemplate) {
                 const change = getUntrackedSnapshot().getChangeRange(cache.snapshot);
                 if (change) {
-                    (0, alien_signals_1.pauseTracking)();
+                    const pausedSub = (0, alien_signals_1.setCurrentSub)(undefined);
                     const templateOffset = base.startTagEnd;
-                    (0, alien_signals_1.resumeTracking)();
+                    (0, alien_signals_1.setCurrentSub)(pausedSub);
                     const newText = getUntrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
                     const newResult = cache.plugin.updateSFCTemplate(cache.result, {
                         start: change.span.start - templateOffset,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.0-alpha.6",
+	"version": "3.0.0-beta.1",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,20 +13,18 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.4.13",
+		"@volar/language-core": "2.4.14",
 		"@vue/compiler-dom": "^3.5.0",
-		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
-		"alien-signals": "^1.0.3",
-		"minimatch": "^9.0.3",
+		"alien-signals": "^2.0.5",
+		"minimatch": "^10.0.1",
 		"muggle-string": "^0.4.1",
 		"path-browserify": "^1.0.1"
 	},
 	"devDependencies": {
-		"@types/minimatch": "^5.1.2",
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
-		"@volar/typescript": "~2.4.13",
+		"@volar/typescript": "2.4.14",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -37,5 +35,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "a7b5649ab4957cd2228f4bbc9205b2008bff58a2"
+	"gitHead": "7a2ea48123679387d7095a81ac49cfc667aeeabb"
 }

package/lib/plugins/vue-style-css.d.ts

@@ -1,3 +0,0 @@
-import type { VueLanguagePlugin } from '../types';
-declare const plugin: VueLanguagePlugin;
-export default plugin;

package/lib/plugins/vue-style-css.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const css = require("css-tree");
-const plugin = () => {
-    return {
-        version: 2.1,
-        compileSFCStyle(lang, style) {
-            if (lang === 'css' || lang === 'scss' || lang === 'sass' || lang === 'less') {
-                return css.parse(style, {
-                    filename: 'test.' + lang,
-                    positions: true,
-                });
-            }
-        },
-    };
-};
-exports.default = plugin;
-//# sourceMappingURL=vue-style-css.js.map

package/lib/utils/vue2TemplateCompiler.d.ts

@@ -1,2 +0,0 @@
-import * as CompilerDOM from '@vue/compiler-dom';
-export declare const compile: typeof CompilerDOM.compile;

package/lib/utils/vue2TemplateCompiler.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compile = void 0;
-const CompilerDOM = require("@vue/compiler-dom");
-const Vue2TemplateCompiler = require('@vue/compiler-vue2/build');
-const compile = (template, options = {}) => {
-    if (typeof template !== 'string') {
-        throw new Error(`[@vue/language-core] compile() first argument must be string.`);
-    }
-    const onError = options.onError;
-    const onWarn = options.onWarn;
-    options.onError = error => {
-        if (error.code === 33 // :key binding allowed in v-for template child in vue 2
-            || error.code === 29 // fix https://github.com/vuejs/language-tools/issues/1638
-        ) {
-            return;
-        }
-        if (onError) {
-            onError(error);
-        }
-        else {
-            throw error;
-        }
-    };
-    const vue2Result = Vue2TemplateCompiler.compile(template, { outputSourceRange: true });
-    for (const error of vue2Result.errors) {
-        onError?.({
-            code: 'vue-template-compiler',
-            name: '',
-            message: error.msg,
-            loc: {
-                source: '',
-                start: { column: -1, line: -1, offset: error.start },
-                end: { column: -1, line: -1, offset: error.end ?? error.start },
-            },
-        });
-    }
-    for (const error of vue2Result.tips) {
-        onWarn?.({
-            code: 'vue-template-compiler',
-            name: '',
-            message: error.msg,
-            loc: {
-                source: '',
-                start: { column: -1, line: -1, offset: error.start },
-                end: { column: -1, line: -1, offset: error.end ?? error.start },
-            },
-        });
-    }
-    return baseCompile(template, Object.assign({}, CompilerDOM.parserOptions, options, {
-        nodeTransforms: [
-            ...CompilerDOM.DOMNodeTransforms,
-            ...(options.nodeTransforms || [])
-        ],
-        directiveTransforms: Object.assign({}, CompilerDOM.DOMDirectiveTransforms, options.directiveTransforms || {}),
-    }));
-};
-exports.compile = compile;
-function baseCompile(template, options = {}) {
-    const onError = options.onError || (error => { throw error; });
-    const isModuleMode = options.mode === 'module';
-    const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
-    if (!prefixIdentifiers && options.cacheHandlers) {
-        onError(CompilerDOM.createCompilerError(49));
-    }
-    if (options.scopeId && !isModuleMode) {
-        onError(CompilerDOM.createCompilerError(50));
-    }
-    const ast = CompilerDOM.baseParse(template, options);
-    const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset(prefixIdentifiers);
-    // v-for > v-if in vue 2
-    const transformIf = nodeTransforms[1];
-    const transformFor = nodeTransforms[3];
-    nodeTransforms[1] = transformFor;
-    nodeTransforms[3] = transformIf;
-    CompilerDOM.transform(ast, Object.assign({}, options, {
-        prefixIdentifiers,
-        nodeTransforms: [
-            ...nodeTransforms,
-            ...(options.nodeTransforms || []) // user transforms
-        ],
-        directiveTransforms: Object.assign({}, directiveTransforms, options.directiveTransforms || {} // user transforms
-        )
-    }));
-    return CompilerDOM.generate(ast, Object.assign({}, options, {
-        prefixIdentifiers
-    }));
-}
-//# sourceMappingURL=vue2TemplateCompiler.js.map