@vue/language-core 3.0.0-alpha.0 → 3.0.0-alpha.10

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

@@ -1,6 +1,6 @@
-import * as CompilerDOM from '@vue/compiler-dom';
+import type * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Code, SfcBlock, SfcBlockAttr, VueCodeInformation } from '../../types';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
@@ -18,4 +18,3 @@ export declare function collectIdentifiers(ts: typeof import('typescript'), node
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
-export declare function generateSfcBlockAttrValue(src: SfcBlockAttr & object, text: string, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/index.js

@@ -6,7 +6,6 @@ exports.collectIdentifiers = collectIdentifiers;
 exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
-exports.generateSfcBlockAttrValue = generateSfcBlockAttrValue;
 const shared_1 = require("../../utils/shared");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
@@ -65,19 +64,4 @@ function generateSfcBlockSection(block, start, end, features) {
         features,
     ];
 }
-function* generateSfcBlockAttrValue(src, text, features) {
-    const { offset, quotes } = src;
-    if (!quotes) {
-        yield [``, 'main', offset, { verification: true }];
-    }
-    yield [
-        `'${text}'`,
-        'main',
-        quotes ? offset - 1 : offset,
-        features
-    ];
-    if (!quotes) {
-        yield [``, 'main', offset + text.length, { __combineOffset: 2 }];
-    }
-}
 //# sourceMappingURL=index.js.map

package/lib/languagePlugin.d.ts

@@ -1,4 +1,4 @@
-import { LanguagePlugin } from '@volar/language-core';
+import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions } from './types';
 import { VueVirtualCode } from './virtualFile/vueFile';

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.js

@@ -26,24 +26,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));
@@ -159,7 +162,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     defaultValue,
                     required,
                     isModel: isDefineModel,
-                    comments: getCommentsRange(ts, node, parents, ast),
+                    comments: getClosestMultiLineCommentRange(ts, node, parents, ast),
                     argNode: options,
                 });
             }
@@ -410,18 +413,20 @@ function getStatementRange(ts, parents, node, ast) {
     }
     return statementRange;
 }
-function getCommentsRange(ts, node, parents, ast) {
+function getClosestMultiLineCommentRange(ts, node, parents, ast) {
     for (let i = parents.length - 1; i >= 0; i--) {
         if (ts.isStatement(node)) {
             break;
         }
         node = parents[i];
     }
-    const comments = ts.getLeadingCommentRanges(ast.text, node.pos);
-    if (comments?.length) {
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
         return {
-            start: comments[0].pos,
-            end: comments.at(-1).end,
+            start: comment.pos,
+            end: comment.end,
         };
     }
 }

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-style-css.d.ts

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

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

@@ -0,0 +1,18 @@
+"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/plugins/vue-template-inline-css.js

@@ -21,7 +21,7 @@ const plugin = () => {
             if (embeddedFile.id !== 'template_inline_css' || !sfc.template?.ast) {
                 return;
             }
-            embeddedFile.parentCodeId = 'template';
+            embeddedFile.parentCodeId = sfc.template.lang === 'md' ? 'root_tags' : 'template';
             embeddedFile.content.push(...generate(sfc.template.ast));
         },
     };

package/lib/plugins/vue-template-inline-ts.js

@@ -37,14 +37,17 @@ const plugin = ctx => {
             return result;
         },
         resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (!embeddedFile.id.startsWith('template_inline_ts_')) {
+                return;
+            }
             // access template content to watch change
-            (() => sfc.template?.content)();
+            void sfc.template?.content;
             const parsed = parseds.get(sfc);
             if (parsed) {
                 const codes = parsed.get(embeddedFile.id);
                 if (codes) {
                     embeddedFile.content.push(...codes);
-                    embeddedFile.parentCodeId = 'template';
+                    embeddedFile.parentCodeId = sfc.template?.lang === 'md' ? 'root_tags' : 'template';
                 }
             }
         },

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;
@@ -138,6 +137,17 @@ export declare const tsCodegen: WeakMap<Sfc, {
     };
     getGeneratedTemplate: () => {
         codes: Code[];
+        currentInfo: {
+            ignoreError?: boolean;
+            expectError?: {
+                token: number;
+                node: import("@vue/compiler-dom").CommentNode;
+            };
+            generic?: {
+                content: string;
+                offset: number;
+            };
+        };
         codeFeatures: {
             all: import("../types").VueCodeInformation;
             none: import("../types").VueCodeInformation;
@@ -155,8 +165,10 @@ 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;
         slots: {
             name: string;
             offset?: number;
@@ -170,10 +182,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         dollarVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
-        lastGenericComment: {
-            content: string;
-            offset: number;
-        } | undefined;
         blockConditions: string[];
         scopedClasses: {
             source: string;
@@ -187,25 +195,26 @@ export declare const tsCodegen: WeakMap<Sfc, {
         templateRefs: Map<string, {
             typeExp: string;
             offset: number;
-        }>;
+        }[]>;
         currentComponent: {
             ctxVar: string;
+            childTypes: string[];
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
+        addTemplateRef(name: string, typeExp: string, offset: number): void;
         accessExternalVariable(name: string, offset?: number): void;
-        hasLocalVariable: (name: string) => boolean;
-        addLocalVariable: (name: string) => void;
-        removeLocalVariable: (name: string) => void;
-        getInternalVariable: () => string;
-        getHoistVariable: (originalVar: string) => string;
-        generateHoistVariables: () => Generator<string, void, unknown>;
-        generateConditionGuards: () => Generator<string, void, unknown>;
-        ignoreError: () => Generator<Code>;
-        expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
-        resetDirectiveComments: (endStr: string) => Generator<Code>;
-        generateAutoImportCompletion: () => Generator<Code>;
+        hasLocalVariable(name: string): boolean;
+        addLocalVariable(name: string): void;
+        removeLocalVariable(name: string): void;
+        getInternalVariable(): string;
+        getHoistVariable(originalVar: string): string;
+        generateHoistVariables(): Generator<string, void, unknown>;
+        generateConditionGuards(): Generator<string, void, unknown>;
+        generateAutoImportCompletion(): Generator<Code>;
+        enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+        exit(): Generator<Code>;
     } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;

package/lib/plugins/vue-tsx.js

@@ -12,6 +12,7 @@ const vueCompilerOptions_1 = require("../parsers/vueCompilerOptions");
 const signals_1 = require("../utils/signals");
 const ts_1 = require("../utils/ts");
 exports.tsCodegen = new WeakMap();
+const validLangs = new Set(['js', 'jsx', 'ts', 'tsx']);
 const plugin = ctx => {
     let appendedGlobalTypes = false;
     return {
@@ -22,11 +23,10 @@ const plugin = ctx => {
         ],
         getEmbeddedCodes(fileName, sfc) {
             const codegen = useCodegen(fileName, sfc);
-            const files = [];
-            if (['js', 'ts', 'jsx', 'tsx'].includes(codegen.getLang())) {
-                files.push({ id: 'script_' + codegen.getLang(), lang: codegen.getLang() });
-            }
-            return files;
+            return [{
+                    id: 'script_' + codegen.getLang(),
+                    lang: codegen.getLang(),
+                }];
         },
         resolveEmbeddedCode(fileName, sfc, embeddedFile) {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
@@ -53,11 +53,23 @@ const plugin = ctx => {
 exports.default = plugin;
 function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
+    const getRawLang = (0, alien_signals_1.computed)(() => {
+        if (sfc.script && sfc.scriptSetup) {
+            if (sfc.scriptSetup.lang !== 'js') {
+                return sfc.scriptSetup.lang;
+            }
+            else {
+                return sfc.script.lang;
+            }
+        }
+        return sfc.scriptSetup?.lang ?? sfc.script?.lang;
+    });
     const getLang = (0, alien_signals_1.computed)(() => {
-        return !sfc.script && !sfc.scriptSetup ? 'ts'
-            : sfc.scriptSetup && sfc.scriptSetup.lang !== 'js' ? sfc.scriptSetup.lang
-                : sfc.script && sfc.script.lang !== 'js' ? sfc.script.lang
-                    : 'js';
+        const rawLang = getRawLang();
+        if (rawLang && validLangs.has(rawLang)) {
+            return rawLang;
+        }
+        return 'ts';
     });
     const getResolvedOptions = (0, alien_signals_1.computed)(() => {
         const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
@@ -68,13 +80,13 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
         }
         return ctx.vueCompilerOptions;
     });
-    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup, false)
+    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script && validLangs.has(sfc.script.lang)
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup)
         : undefined);
-    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup && validLangs.has(sfc.scriptSetup.lang)
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
         : undefined);
-    const getSetupBindingNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    const getSetupBindingNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set();
         const bindings = getScriptSetupRanges()?.bindings;
         if (sfc.scriptSetup && bindings) {
@@ -83,8 +95,8 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
             }
         }
         return newNames;
-    }));
-    const getSetupImportComponentNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    });
+    const getSetupImportComponentNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set();
         const bindings = getScriptSetupRanges()?.bindings;
         if (sfc.scriptSetup && bindings) {
@@ -98,21 +110,21 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
             }
         }
         return newNames;
-    }));
-    const getSetupDestructuredPropNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    });
+    const getSetupDestructuredPropNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set(getScriptSetupRanges()?.defineProps?.destructured?.keys());
         const rest = getScriptSetupRanges()?.defineProps?.destructuredRest;
         if (rest) {
             newNames.add(rest);
         }
         return newNames;
-    }));
-    const getSetupTemplateRefNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    });
+    const getSetupTemplateRefNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set(getScriptSetupRanges()?.useTemplateRef
             .map(({ name }) => name)
             .filter(name => name !== undefined));
         return newNames;
-    }));
+    });
     const setupHasDefineSlots = (0, alien_signals_1.computed)(() => !!getScriptSetupRanges()?.defineSlots);
     const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
     const getSetupPropsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineProps?.name);

package/lib/plugins.d.ts

@@ -1,3 +1,3 @@
-import { VueLanguagePlugin } from './types';
+import { type VueLanguagePlugin } from './types';
 export * from './plugins/shared';
 export declare function createPlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): import("./types").VueLanguagePluginReturn[];

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 | 99 | number;
+    target?: 'auto' | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
@@ -23,6 +23,7 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
+    strictSlotChildren: boolean;
     strictVModel: boolean;
     checkUnknownProps: boolean;
     checkUnknownEvents: boolean;

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/signals.d.ts

@@ -1,2 +1,3 @@
 export declare function computedArray<I, O>(arr: () => I[], getGetter: (item: () => I, index: number) => () => O): readonly Readonly<O>[];
 export declare function computedSet<T>(source: () => Set<T>): () => Set<T>;
+export declare function computedItems<T>(source: () => T[], compareFn: (oldItem: T, newItem: T) => boolean): () => T[];

package/lib/utils/signals.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computedArray = computedArray;
 exports.computedSet = computedSet;
+exports.computedItems = computedItems;
 const alien_signals_1 = require("alien-signals");
 function computedArray(arr, getGetter) {
     const length = (0, alien_signals_1.computed)(() => arr().length);
@@ -51,4 +52,14 @@ function computedSet(source) {
         return newValue;
     });
 }
+function computedItems(source, compareFn) {
+    return (0, alien_signals_1.computed)(oldArr => {
+        oldArr ??= [];
+        const newArr = source();
+        if (oldArr.length === newArr.length && oldArr.every((item, index) => compareFn(item, newArr[index]))) {
+            return oldArr;
+        }
+        return newArr;
+    });
+}
 //# sourceMappingURL=signals.js.map

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) {
@@ -217,6 +217,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
+        strictSlotChildren: strictTemplates,
         strictVModel: strictTemplates,
         checkUnknownProps: strictTemplates,
         checkUnknownEvents: strictTemplates,
@@ -238,9 +239,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'],

package/lib/virtualFile/computedSfc.js

@@ -7,9 +7,9 @@ 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)(() => {
@@ -88,8 +88,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
         const base = computedSfcBlock('style_' + i, 'css', getBlock);
         const getModule = computedAttrValue('__module', base, getBlock);
         const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
-        const getCssVars = (0, alien_signals_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
-        const getClassNames = (0, alien_signals_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
+        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 module() { return getModule(); },
             get scoped() { return getScoped(); },
@@ -127,9 +127,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,