@vue/language-core 2.1.6 → 2.1.8

package/lib/codegen/template/interpolation.js

@@ -8,8 +8,7 @@ const common_1 = require("../common");
 function* generateInterpolation(options, ctx, _code, astHolder, start, data, prefix, suffix) {
     const code = prefix + _code + suffix;
     const ast = (0, common_1.createTsAst)(options.ts, astHolder, code);
-    const vars = [];
-    for (let [section, offset, onlyError] of forEachInterpolationSegment(options.ts, options.templateRefNames, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
+    for (let [section, offset, type] of forEachInterpolationSegment(options.ts, options.destructuredPropNames, options.templateRefNames, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
         if (offset === undefined) {
             yield section;
         }
@@ -26,29 +25,28 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
                 section = section.substring(-offset);
                 offset = 0;
             }
-            if (start !== undefined && data !== undefined) {
-                yield [
-                    section,
-                    'template',
-                    start + offset,
-                    onlyError
-                        ? ctx.codeFeatures.verification
-                        : typeof data === 'function' ? data(start + offset) : data,
-                ];
-            }
-            else {
-                yield section;
+            const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+            if (!shouldSkip) {
+                if (start !== undefined
+                    && data) {
+                    yield [
+                        section,
+                        'template',
+                        start + offset,
+                        type === 'errorMappingOnly'
+                            ? ctx.codeFeatures.verification
+                            : typeof data === 'function' ? data(start + offset) : data,
+                    ];
+                }
+                else {
+                    yield section;
+                }
             }
             yield addSuffix;
         }
     }
-    if (start !== undefined) {
-        for (const v of vars) {
-            v.offset = start + v.offset - prefix.length;
-        }
-    }
 }
-function* forEachInterpolationSegment(ts, templateRefNames, ctx, code, offset, ast) {
+function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, code, offset, ast) {
     let ctxVars = [];
     const varCb = (id, isShorthand) => {
         const text = (0, scriptSetupRanges_1.getNodeText)(ts, id, ast);
@@ -65,6 +63,9 @@ function* forEachInterpolationSegment(ts, templateRefNames, ctx, code, offset, a
                 isShorthand: isShorthand,
                 offset: (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start,
             });
+            if (destructuredPropNames?.has(text)) {
+                return;
+            }
             if (offset !== undefined) {
                 ctx.accessExternalVariable(text, offset + (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start);
             }
@@ -80,13 +81,13 @@ function* forEachInterpolationSegment(ts, templateRefNames, ctx, code, offset, a
             yield [code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
             yield [': ', undefined];
         }
-        else {
-            yield [code.substring(0, ctxVars[0].offset), 0];
+        else if (ctxVars[0].offset > 0) {
+            yield [code.substring(0, ctxVars[0].offset), 0, 'startText'];
         }
         for (let i = 0; i < ctxVars.length - 1; i++) {
             const curVar = ctxVars[i];
             const nextVar = ctxVars[i + 1];
-            yield* generateVar(code, templateRefNames, curVar, nextVar);
+            yield* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar);
             if (nextVar.isShorthand) {
                 yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset + nextVar.text.length), curVar.offset + curVar.text.length];
                 yield [': ', undefined];
@@ -96,17 +97,20 @@ function* forEachInterpolationSegment(ts, templateRefNames, ctx, code, offset, a
             }
         }
         const lastVar = ctxVars.at(-1);
-        yield* generateVar(code, templateRefNames, lastVar);
-        yield [code.substring(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length];
+        yield* generateVar(code, destructuredPropNames, templateRefNames, lastVar);
+        if (lastVar.offset + lastVar.text.length < code.length) {
+            yield [code.substring(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+        }
     }
     else {
         yield [code, 0];
     }
 }
-function* generateVar(code, templateRefNames, curVar, nextVar = curVar) {
+function* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar = curVar) {
     // fix https://github.com/vuejs/language-tools/issues/1205
     // fix https://github.com/vuejs/language-tools/issues/1264
-    yield ['', nextVar.offset, true];
+    yield ['', nextVar.offset, 'errorMappingOnly'];
+    const isDestructuredProp = destructuredPropNames?.has(curVar.text) ?? false;
     const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
     if (isTemplateRef) {
         yield [`__VLS_unref(`, undefined];
@@ -114,7 +118,9 @@ function* generateVar(code, templateRefNames, curVar, nextVar = curVar) {
         yield [`)`, undefined];
     }
     else {
-        yield [`__VLS_ctx.`, undefined];
+        if (!isDestructuredProp) {
+            yield [`__VLS_ctx.`, undefined];
+        }
         yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
     }
 }

package/lib/codegen/template/slotOutlet.js

@@ -6,6 +6,7 @@ const common_1 = require("../common");
 const elementChildren_1 = require("./elementChildren");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
+const inlayHints_1 = require("../inlayHints");
 function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxVar) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
     const varSlot = ctx.getInternalVariable();
@@ -46,6 +47,10 @@ function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxV
         }
         else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
             && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const isShortHand = nameProp.arg?.loc.start.offset === nameProp.exp.loc.start.offset;
+            if (isShortHand) {
+                ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(nameProp.exp.loc, 'name'));
+            }
             const slotExpVar = ctx.getInternalVariable();
             yield `var ${slotExpVar} = `;
             yield* (0, interpolation_1.generateInterpolation)(options, ctx, nameProp.exp.content, nameProp.exp, nameProp.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')');

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

@@ -2,6 +2,6 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, currentComponent: CompilerDOM.ElementNode | undefined, prevNode: CompilerDOM.TemplateChildNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, currentComponent: CompilerDOM.ElementNode | undefined, prevNode: CompilerDOM.TemplateChildNode | undefined, componentCtxVar: string | undefined, isVForChild?: boolean): Generator<Code>;
 export declare function getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

package/lib/codegen/template/templateChild.js

@@ -25,7 +25,7 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar) {
+function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar, isVForChild = false) {
     if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
         const commentText = prevNode.content.trim().split(' ')[0];
         if (commentText.match(/^@vue-skip\b[\s\S]*/)) {
@@ -40,6 +40,10 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
         }
     }
     const shouldInheritRootNodeAttrs = options.inheritAttrs;
+    const cur = node;
+    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
+        cur.codegenNode = cur.codegenNode.value;
+    }
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         let prev;
         if (shouldInheritRootNodeAttrs && node.children.length === 1 && node.children[0].type === CompilerDOM.NodeTypes.ELEMENT) {
@@ -66,7 +70,7 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
             }
             else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
                 || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar);
+                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar, isVForChild);
             }
             else {
                 yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent);

package/lib/codegen/template/vFor.js

@@ -57,7 +57,7 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     }
     let prev;
     for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar, true);
         prev = childNode;
     }
     for (const varName of forBlockVars) {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -9,8 +9,10 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     importComponentNames: Set<string>;
     props: {
         name?: string;
-        destructured?: string[];
+        destructured?: Set<string>;
+        destructuredRest?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }> & {
@@ -24,6 +26,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         name?: string;
         isObjectBindingPattern?: boolean;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }>;
@@ -31,15 +34,18 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     emits: {
         name?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }> & {
+            statement: TextRange;
             hasUnionTypeArg?: boolean;
         };
     };
     expose: {
         name?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }>;
@@ -49,8 +55,11 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         inheritAttrs?: string;
     };
     cssModules: {
-        exp: TextRange;
-        arg?: TextRange;
+        define: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
+            arg?: TextRange;
+            typeArg?: TextRange;
+        }>;
     }[];
     defineProp: {
         localName: TextRange | undefined;
@@ -64,7 +73,8 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     }[];
     templateRefs: {
         name?: string;
-        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+        define: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }>;

package/lib/parsers/scriptSetupRanges.js

@@ -76,6 +76,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     function parseDefineFunction(node) {
         return {
             ..._getStartEnd(node),
+            exp: _getStartEnd(node.expression),
             arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
             typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
         };
@@ -217,7 +218,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 }
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                emits.define = parseDefineFunction(node);
+                emits.define = {
+                    ...parseDefineFunction(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
                 if (ts.isVariableDeclaration(parent)) {
                     emits.name = getNodeText(ts, parent.name, ast);
                 }
@@ -236,30 +240,25 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 if (ts.isVariableDeclaration(parent)) {
                     if (ts.isObjectBindingPattern(parent.name)) {
-                        props.destructured = (0, common_1.collectVars)(ts, parent.name, ast, [], false);
+                        props.destructured = new Set();
+                        const identifiers = (0, common_1.collectIdentifiers)(ts, parent.name, []);
+                        for (const [id, isRest] of identifiers) {
+                            const name = getNodeText(ts, id, ast);
+                            if (isRest) {
+                                props.destructuredRest = name;
+                            }
+                            else {
+                                props.destructured.add(name);
+                            }
+                        }
                     }
                     else {
                         props.name = getNodeText(ts, parent.name, ast);
                     }
                 }
-                let statementRange;
-                for (let i = parents.length - 1; i >= 0; i--) {
-                    if (ts.isStatement(parents[i])) {
-                        const statement = parents[i];
-                        ts.forEachChild(statement, child => {
-                            const range = _getStartEnd(child);
-                            statementRange ??= range;
-                            statementRange.end = range.end;
-                        });
-                        break;
-                    }
-                }
-                if (!statementRange) {
-                    statementRange = _getStartEnd(node);
-                }
                 props.define = {
                     ...parseDefineFunction(node),
-                    statement: statementRange,
+                    statement: getStatementRange(ts, parents, node, ast),
                 };
                 if (node.arguments.length) {
                     props.define.arg = _getStartEnd(node.arguments[0]);
@@ -298,7 +297,6 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.composibles.useTemplateRef.includes(callText) && node.arguments.length && !node.typeArguments?.length) {
                 const define = parseDefineFunction(node);
-                define.arg = _getStartEnd(node.arguments[0]);
                 let name;
                 if (ts.isVariableDeclaration(parent)) {
                     name = getNodeText(ts, parent.name, ast);
@@ -309,13 +307,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 });
             }
             else if (vueCompilerOptions.composibles.useCssModule.includes(callText)) {
-                const module = {
-                    exp: _getStartEnd(node)
-                };
-                if (node.arguments.length) {
-                    module.arg = _getStartEnd(node.arguments[0]);
-                }
-                cssModules.push(module);
+                const define = parseDefineFunction(node);
+                cssModules.push({
+                    define
+                });
             }
         }
         ts.forEachChild(node, child => {
@@ -420,4 +415,22 @@ function getNodeText(ts, node, sourceFile) {
     const { start, end } = getStartEnd(ts, node, sourceFile);
     return sourceFile.text.substring(start, end);
 }
+function getStatementRange(ts, parents, node, sourceFile) {
+    let statementRange;
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(parents[i])) {
+            const statement = parents[i];
+            ts.forEachChild(statement, child => {
+                const range = getStartEnd(ts, child, sourceFile);
+                statementRange ??= range;
+                statementRange.end = range.end;
+            });
+            break;
+        }
+    }
+    if (!statementRange) {
+        statementRange = getStartEnd(ts, node, sourceFile);
+    }
+    return statementRange;
+}
 //# sourceMappingURL=scriptSetupRanges.js.map

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

@@ -1,7 +1,7 @@
 import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    scriptRanges: () => {
+    scriptRanges: import("alien-signals").ISignal<{
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -14,16 +14,18 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }) | undefined;
         classBlockEnd: number | undefined;
         bindings: import("../types").TextRange[];
-    } | undefined;
-    scriptSetupRanges: () => {
+    } | undefined>;
+    scriptSetupRanges: import("alien-signals").ISignal<{
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: import("../types").TextRange[];
         importComponentNames: Set<string>;
         props: {
             name?: string;
-            destructured?: string[];
+            destructured?: Set<string>;
+            destructuredRest?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }> & {
@@ -37,6 +39,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             name?: string;
             isObjectBindingPattern?: boolean;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }>;
@@ -44,15 +47,18 @@ export declare const tsCodegen: WeakMap<Sfc, {
         emits: {
             name?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }> & {
+                statement: import("../types").TextRange;
                 hasUnionTypeArg?: boolean;
             };
         };
         expose: {
             name?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }>;
@@ -62,8 +68,11 @@ export declare const tsCodegen: WeakMap<Sfc, {
             inheritAttrs?: string;
         };
         cssModules: {
-            exp: import("../types").TextRange;
-            arg?: import("../types").TextRange;
+            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
+                arg?: import("../types").TextRange;
+                typeArg?: import("../types").TextRange;
+            }>;
         }[];
         defineProp: {
             localName: import("../types").TextRange | undefined;
@@ -77,14 +86,15 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         templateRefs: {
             name?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }>;
         }[];
-    } | undefined;
-    lang: () => string;
-    generatedScript: () => {
+    } | undefined>;
+    lang: import("alien-signals").ISignal<string>;
+    generatedScript: import("alien-signals").ISignal<{
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
@@ -103,9 +113,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
             readonly TypePropsToOption: string;
             readonly OmitIndexSignature: string;
         };
-        inlayHints: import("../codegen/types").InlayHintInfo[];
-    };
-    generatedTemplate: () => {
+        inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
+    }>;
+    generatedTemplate: import("alien-signals").ISignal<{
         codes: Code[];
         slots: {
             name: string;
@@ -141,10 +151,11 @@ export declare const tsCodegen: WeakMap<Sfc, {
             offset: number;
         }[];
         emptyClassOffsets: number[];
-        inlayHints: import("../codegen/types").InlayHintInfo[];
+        inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
         hasSlot: boolean;
         inheritedAttrVars: Set<unknown>;
-        templateRefs: Map<string, [string, number]>;
+        templateRefs: Map<string, [varName: string, offset: number]>;
+        singleRootElType: string | undefined;
         singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
         accessExternalVariable(name: string, offset?: number): void;
         hasLocalVariable: (name: string) => boolean;
@@ -155,7 +166,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
         resetDirectiveComments: (endStr: string) => Generator<Code>;
         generateAutoImportCompletion: () => Generator<Code>;
-    } | undefined;
+    } | undefined>;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;

package/lib/plugins/vue-tsx.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
-const computeds_1 = require("computeds");
+const alien_signals_1 = require("alien-signals");
 const path_browserify_1 = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
@@ -20,15 +20,15 @@ const plugin = ctx => {
         getEmbeddedCodes(fileName, sfc) {
             const tsx = useTsx(fileName, sfc);
             const files = [];
-            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang())) {
-                files.push({ id: 'script_' + tsx.lang(), lang: tsx.lang() });
+            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang.get())) {
+                files.push({ id: 'script_' + tsx.lang.get(), lang: tsx.lang.get() });
             }
             return files;
         },
         resolveEmbeddedCode(fileName, sfc, embeddedFile) {
             const _tsx = useTsx(fileName, sfc);
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
-                const tsx = _tsx.generatedScript();
+                const tsx = _tsx.generatedScript.get();
                 if (tsx) {
                     const content = [...tsx.codes];
                     embeddedFile.content = content;
@@ -52,19 +52,19 @@ const plugin = ctx => {
 exports.default = plugin;
 function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
-    const lang = (0, computeds_1.computed)(() => {
+    const lang = (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 scriptRanges = (0, computeds_1.computed)(() => _sfc.script
+    const scriptRanges = (0, alien_signals_1.computed)(() => _sfc.script
         ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
         : undefined);
-    const scriptSetupRanges = (0, computeds_1.computed)(() => _sfc.scriptSetup
+    const scriptSetupRanges = (0, alien_signals_1.computed)(() => _sfc.scriptSetup
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
         : undefined);
-    const generatedTemplate = (0, computeds_1.computed)(() => {
+    const generatedTemplate = (0, alien_signals_1.computed)(() => {
         if (ctx.vueCompilerOptions.skipTemplateCodegen || !_sfc.template) {
             return;
         }
@@ -75,13 +75,14 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
             vueCompilerOptions: ctx.vueCompilerOptions,
             template: _sfc.template,
             edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
-            scriptSetupBindingNames: scriptSetupBindingNames(),
-            scriptSetupImportComponentNames: scriptSetupImportComponentNames(),
-            templateRefNames: templateRefNames(),
-            hasDefineSlots: hasDefineSlots(),
-            slotsAssignName: slotsAssignName(),
-            propsAssignName: propsAssignName(),
-            inheritAttrs: inheritAttrs(),
+            scriptSetupBindingNames: scriptSetupBindingNames.get(),
+            scriptSetupImportComponentNames: scriptSetupImportComponentNames.get(),
+            destructuredPropNames: destructuredPropNames.get(),
+            templateRefNames: templateRefNames.get(),
+            hasDefineSlots: hasDefineSlots.get(),
+            slotsAssignName: slotsAssignName.get(),
+            propsAssignName: propsAssignName.get(),
+            inheritAttrs: inheritAttrs.get(),
         });
         let current = codegen.next();
         while (!current.done) {
@@ -94,9 +95,9 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
             codes: codes,
         };
     });
-    const scriptSetupBindingNames = (0, computeds_1.computed)(oldNames => {
+    const scriptSetupBindingNames = (0, alien_signals_1.computed)(oldNames => {
         const newNames = new Set();
-        const bindings = scriptSetupRanges()?.bindings;
+        const bindings = scriptSetupRanges.get()?.bindings;
         if (_sfc.scriptSetup && bindings) {
             for (const binding of bindings) {
                 newNames.add(_sfc.scriptSetup?.content.substring(binding.start, binding.end));
@@ -107,15 +108,26 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         return newNames;
     });
-    const scriptSetupImportComponentNames = (0, computeds_1.computed)(oldNames => {
-        const newNames = scriptSetupRanges()?.importComponentNames ?? new Set();
+    const scriptSetupImportComponentNames = (0, alien_signals_1.computed)(oldNames => {
+        const newNames = scriptSetupRanges.get()?.importComponentNames ?? new Set();
         if (oldNames && twoSetsEqual(newNames, oldNames)) {
             return oldNames;
         }
         return newNames;
     });
-    const templateRefNames = (0, computeds_1.computed)(oldNames => {
-        const newNames = new Set(scriptSetupRanges()?.templateRefs
+    const destructuredPropNames = (0, alien_signals_1.computed)(oldNames => {
+        const newNames = scriptSetupRanges.get()?.props.destructured ?? new Set();
+        const rest = scriptSetupRanges.get()?.props.destructuredRest;
+        if (rest) {
+            newNames.add(rest);
+        }
+        if (oldNames && twoSetsEqual(newNames, oldNames)) {
+            return oldNames;
+        }
+        return newNames;
+    });
+    const templateRefNames = (0, alien_signals_1.computed)(oldNames => {
+        const newNames = new Set(scriptSetupRanges.get()?.templateRefs
             .map(({ name }) => name)
             .filter(name => name !== undefined));
         if (oldNames && twoSetsEqual(newNames, oldNames)) {
@@ -123,14 +135,14 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         return newNames;
     });
-    const hasDefineSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
-    const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
-    const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
-    const inheritAttrs = (0, computeds_1.computed)(() => {
-        const value = scriptSetupRanges()?.options.inheritAttrs ?? scriptRanges()?.exportDefault?.inheritAttrsOption;
+    const hasDefineSlots = (0, alien_signals_1.computed)(() => !!scriptSetupRanges.get()?.slots.define);
+    const slotsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.slots.name);
+    const propsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.props.name);
+    const inheritAttrs = (0, alien_signals_1.computed)(() => {
+        const value = scriptSetupRanges.get()?.options.inheritAttrs ?? scriptRanges.get()?.exportDefault?.inheritAttrsOption;
         return value !== 'false';
     });
-    const generatedScript = (0, computeds_1.computed)(() => {
+    const generatedScript = (0, alien_signals_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
         let generatedLength = 0;
@@ -138,10 +150,10 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
             ts,
             fileBaseName: path_browserify_1.posix.basename(fileName),
             sfc: _sfc,
-            lang: lang(),
-            scriptRanges: scriptRanges(),
-            scriptSetupRanges: scriptSetupRanges(),
-            templateCodegen: generatedTemplate(),
+            lang: lang.get(),
+            scriptRanges: scriptRanges.get(),
+            scriptSetupRanges: scriptSetupRanges.get(),
+            templateCodegen: generatedTemplate.get(),
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
             edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,

package/lib/types.d.ts

@@ -45,7 +45,9 @@ export interface VueCompilerOptions {
     experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
-    __setupedGlobalTypes?: boolean;
+    __setupedGlobalTypes?: true | {
+        absolutePath: string;
+    };
     __test?: boolean;
 }
 export declare const validVersions: readonly [2, 2.1];

package/lib/utils/parseCssClassNames.d.ts

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