@vue/language-core 3.0.1 → 3.0.3

package/lib/codegen/globalTypes.js

@@ -14,7 +14,7 @@ function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEv
 }
 function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
     const fnPropsType = `(T extends { $props: infer Props } ? Props : {})${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
-    let text = ``;
+    let text = `// @ts-nocheck\nexport {};\n`;
     if (target < 3.5) {
         text += `
 ; declare module '${lib}' {
@@ -68,14 +68,6 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 			expose?: (exposed: T) => void,
 		}
 	};
-	type __VLS_NormalizeSlotReturns<S, R = NonNullable<S> extends (...args: any) => infer K ? K : any> = R extends any[] ? {
-		[K in keyof R]: R[K] extends infer V
-			? V extends Element ? V
-			: V extends new (...args: any) => infer R ? ReturnType<__VLS_FunctionalComponent<R>>
-			: V extends (...args: any) => infer R ? R
-			: any
-			: never
-	} : R;
 	type __VLS_IsFunction<T, K> = K extends keyof T
 		? __VLS_IsAny<T[K]> extends false
 		? unknown extends T[K]
@@ -143,7 +135,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		index: number,
 	][];
 	function __VLS_getSlotParameters<S, D extends S>(slot: S, decl?: D):
-		__VLS_PickNotAny<NonNullable<D>, (...args: any) => any> extends (...args: infer P) => any ? P : any[];
+		D extends (...args: infer P) => any ? P : any[];
 	function __VLS_asFunctionalDirective<T>(dir: T): T extends import('${lib}').ObjectDirective
 		? NonNullable<T['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>
 		: T extends (...args: any) => any

package/lib/codegen/script/component.js

@@ -6,6 +6,7 @@ exports.generateEmitsOption = generateEmitsOption;
 exports.generatePropsOption = generatePropsOption;
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
+const merge_1 = require("../utils/merge");
 function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     if (options.sfc.script && options.scriptRanges?.exportDefault
         && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
@@ -17,14 +18,21 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
         yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
     }
     yield `setup() {${utils_1.newLine}`;
-    yield `return {${utils_1.newLine}`;
+    const returns = [];
     if (ctx.bypassDefineComponent) {
+        yield* `const __VLS_returns = {${utils_1.newLine}`;
         yield* generateComponentSetupReturns(scriptSetupRanges);
+        yield `}${utils_1.endOfLine}`;
+        returns.push(`typeof __VLS_returns`);
     }
     if (scriptSetupRanges.defineExpose) {
-        yield `...__VLS_exposed,${utils_1.newLine}`;
+        returns.push(`typeof __VLS_exposed`);
+    }
+    if (returns.length) {
+        yield `return {} as `;
+        yield* (0, merge_1.generateIntersectMerge)(returns);
+        yield utils_1.endOfLine;
     }
-    yield `}${utils_1.endOfLine}`;
     yield `},${utils_1.newLine}`;
     if (!ctx.bypassDefineComponent) {
         const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
@@ -60,135 +68,79 @@ function* generateComponentSetupReturns(scriptSetupRanges) {
     }
 }
 function* generateEmitsOption(options, scriptSetupRanges) {
-    const codes = [];
+    const optionCodes = [];
+    const typeOptionCodes = [];
     if (scriptSetupRanges.defineModel.length) {
-        codes.push({
-            optionExp: `{} as __VLS_NormalizeEmits<typeof __VLS_modelEmit>`,
-            typeOptionType: `__VLS_ModelEmit`,
-        });
+        optionCodes.push(`{} as __VLS_NormalizeEmits<typeof __VLS_modelEmit>`);
+        typeOptionCodes.push(`__VLS_ModelEmit`);
     }
     if (scriptSetupRanges.defineEmits) {
         const { name, typeArg, hasUnionTypeArg } = scriptSetupRanges.defineEmits;
-        codes.push({
-            optionExp: `{} as __VLS_NormalizeEmits<typeof ${name ?? '__VLS_emit'}>`,
-            typeOptionType: typeArg && !hasUnionTypeArg
-                ? `__VLS_Emit`
-                : undefined,
-        });
-    }
-    if (options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionType)) {
-        if (codes.length === 1) {
-            yield `__typeEmits: {} as `;
-            yield codes[0].typeOptionType;
-            yield `,${utils_1.newLine}`;
+        optionCodes.push(`{} as __VLS_NormalizeEmits<typeof ${name ?? '__VLS_emit'}>`);
+        if (typeArg && !hasUnionTypeArg) {
+            typeOptionCodes.push(`__VLS_Emit`);
         }
-        else if (codes.length >= 2) {
-            yield `__typeEmits: {} as `;
-            yield codes[0].typeOptionType;
-            for (let i = 1; i < codes.length; i++) {
-                yield ` & `;
-                yield codes[i].typeOptionType;
-            }
-            yield `,${utils_1.newLine}`;
+        else {
+            typeOptionCodes.length = 0;
         }
     }
-    else if (codes.every(code => code.optionExp)) {
-        if (codes.length === 1) {
-            yield `emits: `;
-            yield codes[0].optionExp;
-            yield `,${utils_1.newLine}`;
-        }
-        else if (codes.length >= 2) {
-            yield `emits: {${utils_1.newLine}`;
-            for (const code of codes) {
-                yield `...`;
-                yield code.optionExp;
-                yield `,${utils_1.newLine}`;
-            }
-            yield `},${utils_1.newLine}`;
-        }
+    if (options.vueCompilerOptions.target >= 3.5 && typeOptionCodes.length) {
+        yield `__typeEmits: {} as `;
+        yield* (0, merge_1.generateIntersectMerge)(typeOptionCodes);
+        yield `,${utils_1.newLine}`;
+    }
+    else if (optionCodes.length) {
+        yield `emits: `;
+        yield* (0, merge_1.generateSpreadMerge)(optionCodes);
+        yield `,${utils_1.newLine}`;
     }
 }
 function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasEmitsOption, inheritAttrs) {
-    const codes = [];
-    if (ctx.generatedPropsType) {
-        if (options.vueCompilerOptions.target >= 3.6) {
-            codes.push({
-                optionExp: '{}',
-                typeOptionExp: `{} as __VLS_PublicProps`,
-            });
-        }
-        else {
-            codes.push({
-                optionExp: [
-                    `{} as `,
-                    scriptSetupRanges.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
-                    `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
-                    scriptSetupRanges.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
-                ].join(''),
-                typeOptionExp: `{} as __VLS_PublicProps`,
-            });
-        }
-    }
-    if (scriptSetupRanges.defineProps?.arg) {
-        const { arg } = scriptSetupRanges.defineProps;
-        codes.push({
-            optionExp: (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.navigation),
-            typeOptionExp: undefined,
-        });
-    }
+    const getOptionCodes = [];
+    const typeOptionCodes = [];
     if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
         let attrsType = `Partial<__VLS_InheritedAttrs>`;
         if (hasEmitsOption) {
             attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
         }
-        const propsType = `__VLS_PickNotAny<${ctx.localTypes.OmitIndexSignature}<${attrsType}>, {}>`;
-        const optionType = `${ctx.localTypes.TypePropsToOption}<${propsType}>`;
-        codes.unshift({
-            optionExp: codes.length
-                ? `{} as ${optionType}`
-                // workaround for https://github.com/vuejs/core/pull/7419
-                : `{} as keyof ${propsType} extends never ? never: ${optionType}`,
-            typeOptionExp: `{} as ${attrsType}`,
+        getOptionCodes.push(() => {
+            const propsType = `__VLS_PickNotAny<${ctx.localTypes.OmitIndexSignature}<${attrsType}>, {}>`;
+            const optionType = `${ctx.localTypes.TypePropsToOption}<${propsType}>`;
+            return `{} as ${optionType}`;
         });
+        typeOptionCodes.push(`{} as ${attrsType}`);
+    }
+    if (ctx.generatedPropsType) {
+        if (options.vueCompilerOptions.target < 3.6) {
+            getOptionCodes.push(() => {
+                const propsType = `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`;
+                return `{} as ` + (scriptSetupRanges.withDefaults?.arg
+                    ? `${ctx.localTypes.WithDefaults}<${propsType}, typeof __VLS_withDefaultsArg>`
+                    : propsType);
+            });
+        }
+        typeOptionCodes.push(`{} as __VLS_PublicProps`);
     }
-    const useTypeOption = options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionExp);
-    const useOption = !useTypeOption || scriptSetupRanges.withDefaults;
+    if (scriptSetupRanges.defineProps?.arg) {
+        const { arg } = scriptSetupRanges.defineProps;
+        getOptionCodes.push(() => (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.navigation));
+        typeOptionCodes.length = 0;
+    }
+    const useTypeOption = options.vueCompilerOptions.target >= 3.5 && typeOptionCodes.length;
+    const useOption = (!useTypeOption || scriptSetupRanges.withDefaults) && getOptionCodes.length;
     if (useTypeOption) {
         if (options.vueCompilerOptions.target >= 3.6
             && scriptSetupRanges.withDefaults?.arg) {
             yield `__defaults: __VLS_withDefaultsArg,${utils_1.newLine}`;
         }
-        if (codes.length === 1) {
-            yield `__typeProps: `;
-            yield codes[0].typeOptionExp;
-            yield `,${utils_1.newLine}`;
-        }
-        else if (codes.length >= 2) {
-            yield `__typeProps: {${utils_1.newLine}`;
-            for (const { typeOptionExp } of codes) {
-                yield `...`;
-                yield typeOptionExp;
-                yield `,${utils_1.newLine}`;
-            }
-            yield `},${utils_1.newLine}`;
-        }
+        yield `__typeProps: `;
+        yield* (0, merge_1.generateSpreadMerge)(typeOptionCodes);
+        yield `,${utils_1.newLine}`;
     }
     if (useOption) {
-        if (codes.length === 1) {
-            yield `props: `;
-            yield codes[0].optionExp;
-            yield `,${utils_1.newLine}`;
-        }
-        else if (codes.length >= 2) {
-            yield `props: {${utils_1.newLine}`;
-            for (const { optionExp } of codes) {
-                yield `...`;
-                yield optionExp;
-                yield `,${utils_1.newLine}`;
-            }
-            yield `},${utils_1.newLine}`;
-        }
+        yield `props: `;
+        yield* (0, merge_1.generateSpreadMerge)(getOptionCodes.map(fn => fn()));
+        yield `,${utils_1.newLine}`;
     }
 }
 //# sourceMappingURL=component.js.map

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

@@ -18,7 +18,6 @@ export interface ScriptCodegenOptions {
     } | undefined;
     destructuredPropNames: Set<string>;
     templateRefNames: Set<string>;
-    appendGlobalTypes: boolean;
 }
 export declare function generateScript(options: ScriptCodegenOptions): Generator<Code, ScriptCodegenContext>;
 export declare function generateScriptSectionPartiallyEnding(source: string, end: number, mark: string, delimiter?: string): Generator<Code>;

package/lib/codegen/script/index.js

@@ -4,7 +4,6 @@ exports.generateScript = generateScript;
 exports.generateScriptSectionPartiallyEnding = generateScriptSectionPartiallyEnding;
 const path = require("path-browserify");
 const codeFeatures_1 = require("../codeFeatures");
-const globalTypes_1 = require("../globalTypes");
 const utils_1 = require("../utils");
 const componentSelf_1 = require("./componentSelf");
 const context_1 = require("./context");
@@ -13,22 +12,7 @@ const src_1 = require("./src");
 const template_1 = require("./template");
 function* generateScript(options) {
     const ctx = (0, context_1.createScriptCodegenContext)(options);
-    if (options.vueCompilerOptions.__setupedGlobalTypes) {
-        const globalTypes = options.vueCompilerOptions.__setupedGlobalTypes;
-        if (typeof globalTypes === 'object') {
-            let relativePath = path.relative(path.dirname(options.fileName), globalTypes.absolutePath);
-            if (relativePath !== globalTypes.absolutePath && !relativePath.startsWith('./') && !relativePath.startsWith('../')) {
-                relativePath = './' + relativePath;
-            }
-            yield `/// <reference types="${relativePath}" />${utils_1.newLine}`;
-        }
-        else {
-            yield `/// <reference types=".vue-global-types/${(0, globalTypes_1.getGlobalTypesFileName)(options.vueCompilerOptions)}" />${utils_1.newLine}`;
-        }
-    }
-    else {
-        yield `/// <reference path="./__VLS_fake.d.ts" />`;
-    }
+    yield* generateGlobalTypesPath(options);
     if (options.sfc.script?.src) {
         yield* (0, src_1.generateSrc)(options.sfc.script.src);
     }
@@ -106,14 +90,29 @@ function* generateScript(options) {
         yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
     }
     yield* ctx.localTypes.generate([...ctx.localTypes.getUsedNames()]);
-    if (options.appendGlobalTypes) {
-        yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions);
-    }
     if (options.sfc.scriptSetup) {
         yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, codeFeatures_1.codeFeatures.verification];
     }
     return ctx;
 }
+function* generateGlobalTypesPath(options) {
+    const globalTypesPath = options.vueCompilerOptions.globalTypesPath(options.fileName);
+    if (!globalTypesPath) {
+        yield `/* placeholder */${utils_1.newLine}`;
+    }
+    else if (path.isAbsolute(globalTypesPath)) {
+        let relativePath = path.relative(path.dirname(options.fileName), globalTypesPath);
+        if (relativePath !== globalTypesPath
+            && !relativePath.startsWith('./')
+            && !relativePath.startsWith('../')) {
+            relativePath = './' + relativePath;
+        }
+        yield `/// <reference types="${relativePath}" />${utils_1.newLine}`;
+    }
+    else {
+        yield `/// <reference types="${globalTypesPath}" />${utils_1.newLine}`;
+    }
+}
 function* generateScriptSectionPartiallyEnding(source, end, mark, delimiter = 'debugger') {
     yield delimiter;
     yield ['', source, end, codeFeatures_1.codeFeatures.verification];

package/lib/codegen/script/template.js

@@ -11,6 +11,7 @@ const context_1 = require("../template/context");
 const interpolation_1 = require("../template/interpolation");
 const styleScopedClasses_1 = require("../template/styleScopedClasses");
 const utils_1 = require("../utils");
+const merge_1 = require("../utils/merge");
 function* generateTemplate(options, ctx) {
     ctx.generatedTemplate = true;
     const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
@@ -33,19 +34,8 @@ function* generateTemplateCtx(options) {
         exps.push(`{} as __VLS_StyleModules`);
     }
     yield `const __VLS_ctx = `;
-    if (exps.length === 1) {
-        yield exps[0];
-        yield `${utils_1.endOfLine}`;
-    }
-    else {
-        yield `{${utils_1.newLine}`;
-        for (const exp of exps) {
-            yield `...`;
-            yield exp;
-            yield `,${utils_1.newLine}`;
-        }
-        yield `}${utils_1.endOfLine}`;
-    }
+    yield* (0, merge_1.generateSpreadMerge)(exps);
+    yield utils_1.endOfLine;
 }
 function* generateTemplateElements() {
     yield `let __VLS_elements!: __VLS_IntrinsicElements${utils_1.endOfLine}`;
@@ -65,10 +55,7 @@ function* generateTemplateComponents(options) {
         types.push(`typeof __VLS_componentsOption`);
     }
     yield `type __VLS_LocalComponents =`;
-    for (const type of types) {
-        yield ` & `;
-        yield type;
-    }
+    yield* (0, merge_1.generateIntersectMerge)(types);
     yield utils_1.endOfLine;
     yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
@@ -87,10 +74,7 @@ function* generateTemplateDirectives(options) {
         types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }
     yield `type __VLS_LocalDirectives =`;
-    for (const type of types) {
-        yield ` & `;
-        yield type;
-    }
+    yield* (0, merge_1.generateIntersectMerge)(types);
     yield utils_1.endOfLine;
     yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
 }

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

@@ -163,7 +163,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     }[]>;
     currentComponent: {
         ctxVar: string;
-        childTypes: string[];
         used: boolean;
     } | undefined;
     singleRootElTypes: string[];

package/lib/codegen/template/element.js

@@ -35,10 +35,8 @@ function* generateComponent(options, ctx, node) {
     const componentVNodeVar = ctx.getInternalVariable();
     const componentCtxVar = ctx.getInternalVariable();
     const isComponentTag = node.tag.toLowerCase() === 'component';
-    ctx.currentComponent?.childTypes.push(`typeof ${componentVNodeVar}`);
     ctx.currentComponent = {
         ctxVar: componentCtxVar,
-        childTypes: [],
         used: false,
     };
     let props = node.props;
@@ -98,7 +96,7 @@ function* generateComponent(options, ctx, node) {
         }
         yield `)${utils_1.endOfLine}`;
     }
-    else if (!isComponentTag) {
+    else {
         yield `const ${componentOriginalVar} = ({} as __VLS_WithComponent<'${getCanonicalComponentName(node.tag)}', __VLS_LocalComponents, `;
         if (options.selfComponentName && possibleOriginalNames.includes(options.selfComponentName)) {
             yield `typeof __VLS_self & (new () => { `
@@ -137,9 +135,6 @@ function* generateComponent(options, ctx, node) {
             yield `${utils_1.endOfLine}`;
         }
     }
-    else {
-        yield `const ${componentOriginalVar} = {} as any${utils_1.endOfLine}`;
-    }
     yield `// @ts-ignore${utils_1.newLine}`;
     yield `const ${componentFunctionalVar} = __VLS_asFunctionalComponent(${componentOriginalVar}, new ${componentOriginalVar}({${utils_1.newLine}`;
     yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, false);
@@ -199,7 +194,6 @@ function* generateElement(options, ctx, node) {
         ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
         : undefined;
     const failedPropExps = [];
-    ctx.currentComponent?.childTypes.push(`__VLS_NativeElements['${node.tag}']`);
     yield `__VLS_asFunctionalElement(__VLS_elements`;
     yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
     if (endTagOffset !== undefined) {

package/lib/codegen/template/elementProps.js

@@ -4,8 +4,8 @@ exports.generateElementProps = generateElementProps;
 exports.generatePropExp = generatePropExp;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
-const minimatch_1 = require("minimatch");
 const muggle_string_1 = require("muggle-string");
+const picomatch_1 = require("picomatch");
 const shared_2 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const inlayHints_1 = require("../inlayHints");
@@ -65,7 +65,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 propName = getModelPropName(node, options.vueCompilerOptions);
             }
             if (propName === undefined
-                || options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern))) {
+                || options.vueCompilerOptions.dataAttributes.some(pattern => (0, picomatch_1.isMatch)(propName, pattern))) {
                 if (prop.exp && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
                     failedPropExps?.push({ node: prop.exp, prefix: `(`, suffix: `)` });
                 }
@@ -111,7 +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))
+            if (options.vueCompilerOptions.dataAttributes.some(pattern => (0, picomatch_1.isMatch)(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'
@@ -218,7 +218,7 @@ function getShouldCamelize(options, prop, propName) {
         || !prop.arg
         || (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))
         && (0, shared_2.hyphenateAttr)(propName) === propName
-        && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern));
+        && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, picomatch_1.isMatch)(propName, pattern));
 }
 function getPropsCodeInfo(ctx, strictPropsCheck) {
     return ctx.resolveCodeFeatures({

package/lib/codegen/template/index.js

@@ -58,10 +58,10 @@ function* generateSlots(options, ctx) {
         for (const slot of ctx.slots) {
             yield `${utils_1.newLine}& { `;
             if (slot.name && slot.offset !== undefined) {
-                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, ctx.codeFeatures.withoutHighlightAndCompletion);
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, ctx.codeFeatures.navigation);
             }
             else {
-                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.navigation, `default`);
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }

package/lib/codegen/template/interpolation.js

@@ -70,7 +70,7 @@ function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, t
                 });
             }
         };
-        ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, ctx));
+        ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, ctx, [], true));
     }
     ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
     if (ctxVars.length) {
@@ -122,7 +122,7 @@ function* generateVar(templateRefNames, ctx, code, offset, curVar) {
         yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
     }
 }
-function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true) {
+function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
     if (ts.isIdentifier(node)) {
         cb(node, false);
     }
@@ -130,51 +130,55 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
         cb(node.name, true);
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars, false);
+        walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars);
     }
     else if (ts.isVariableDeclaration(node)) {
-        (0, utils_1.collectVars)(ts, node.name, ast, blockVars);
-        for (const varName of blockVars) {
-            ctx.addLocalVariable(varName);
+        const bindingNames = (0, utils_1.collectBindingNames)(ts, node.name, ast);
+        for (const name of bindingNames) {
+            ctx.addLocalVariable(name);
+            blockVars.push(name);
         }
         if (node.initializer) {
-            walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars, false);
+            walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars);
         }
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-        processFunction(ts, node, ast, cb, ctx);
+        walkIdentifiersInFunction(ts, node, ast, cb, ctx);
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
             if (ts.isPropertyAssignment(prop)) {
                 // fix https://github.com/vuejs/language-tools/issues/1176
                 if (ts.isComputedPropertyName(prop.name)) {
-                    walkIdentifiers(ts, prop.name.expression, ast, cb, ctx, blockVars, false);
+                    walkIdentifiers(ts, prop.name.expression, ast, cb, ctx, blockVars);
                 }
-                walkIdentifiers(ts, prop.initializer, ast, cb, ctx, blockVars, false);
-            } // fix https://github.com/vuejs/language-tools/issues/1156
+                walkIdentifiers(ts, prop.initializer, ast, cb, ctx, blockVars);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1156
             else if (ts.isShorthandPropertyAssignment(prop)) {
-                walkIdentifiers(ts, prop, ast, cb, ctx, blockVars, false);
-            } // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
+                walkIdentifiers(ts, prop, ast, cb, ctx, blockVars);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
             else if (ts.isSpreadAssignment(prop)) {
                 // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
-                walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars, false);
-            } // fix https://github.com/vuejs/language-tools/issues/4604
+                walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/4604
             else if (ts.isFunctionLike(prop) && prop.body) {
-                processFunction(ts, prop, ast, cb, ctx);
+                walkIdentifiersInFunction(ts, prop, ast, cb, ctx);
             }
         }
     }
-    else if (ts.isTypeReferenceNode(node)) {
-        // fix https://github.com/vuejs/language-tools/issues/1422
-        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    // fix https://github.com/vuejs/language-tools/issues/1422
+    else if (ts.isTypeNode(node)) {
+        walkIdentifiersInTypeNode(ts, node, cb);
     }
     else {
         const _blockVars = blockVars;
         if (ts.isBlock(node)) {
             blockVars = [];
         }
-        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, ctx, blockVars, false));
+        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, ctx, blockVars));
         if (ts.isBlock(node)) {
             for (const varName of blockVars) {
                 ctx.removeLocalVariable(varName);
@@ -188,30 +192,34 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
         }
     }
 }
-function processFunction(ts, node, ast, cb, ctx) {
+function walkIdentifiersInFunction(ts, node, ast, cb, ctx) {
     const functionArgs = [];
     for (const param of node.parameters) {
-        (0, utils_1.collectVars)(ts, param.name, ast, functionArgs);
+        functionArgs.push(...(0, utils_1.collectBindingNames)(ts, param.name, ast));
         if (param.type) {
-            walkIdentifiers(ts, param.type, ast, cb, ctx);
+            walkIdentifiersInTypeNode(ts, param.type, cb);
         }
     }
     for (const varName of functionArgs) {
         ctx.addLocalVariable(varName);
     }
     if (node.body) {
-        walkIdentifiers(ts, node.body, ast, cb, ctx);
+        walkIdentifiers(ts, node.body, ast, cb, ctx, [], true);
     }
     for (const varName of functionArgs) {
         ctx.removeLocalVariable(varName);
     }
 }
-function walkIdentifiersInTypeReference(ts, node, cb) {
-    if (ts.isTypeQueryNode(node) && ts.isIdentifier(node.exprName)) {
-        cb(node.exprName, false);
+function walkIdentifiersInTypeNode(ts, node, cb) {
+    if (ts.isTypeQueryNode(node)) {
+        let id = node.exprName;
+        while (!ts.isIdentifier(id)) {
+            id = id.left;
+        }
+        cb(id, false);
     }
     else {
-        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+        ts.forEachChild(node, node => walkIdentifiersInTypeNode(ts, node, cb));
     }
 }
 function shouldIdentifierSkipped(ctx, text, destructuredPropNames) {

package/lib/codegen/template/vFor.js

@@ -13,7 +13,7 @@ function* generateVFor(options, ctx, node) {
     yield `for (const [`;
     if (leftExpressionRange && leftExpressionText) {
         const collectAst = (0, utils_1.createTsAst)(options.ts, ctx.inlineTsAsts, `const [${leftExpressionText}]`);
-        (0, utils_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
+        forBlockVars.push(...(0, utils_1.collectBindingNames)(options.ts, collectAst, collectAst));
         yield [
             leftExpressionText,
             'template',

package/lib/codegen/template/vSlot.js

@@ -35,7 +35,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
     }
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, utils_1.createTsAst)(options.ts, ctx.inlineTsAsts, `(${slotDir.exp.content}) => {}`);
-        (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
+        slotBlockVars.push(...(0, utils_1.collectBindingNames)(options.ts, slotAst, slotAst));
         yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
     }
     for (const varName of slotBlockVars) {
@@ -45,11 +45,6 @@ function* generateVSlot(options, ctx, node, slotDir) {
     for (const varName of slotBlockVars) {
         ctx.removeLocalVariable(varName);
     }
-    if (options.vueCompilerOptions.strictSlotChildren && node.children.length) {
-        yield `(): __VLS_NormalizeSlotReturns<typeof ${slotVar}> => (`;
-        yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, `{} as [`, ...ctx.currentComponent.childTypes.map(name => `${name}, `), `]`);
-        yield `)${utils_1.endOfLine}`;
-    }
     if (slotDir) {
         let isStatic = true;
         if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -103,7 +98,7 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
         nextStart = end;
     }
     yield chunk(nextStart, expression.equalsGreaterThanToken.pos - 1);
-    yield `] = __VLS_getSlotParameters(${slotVar}`;
+    yield `] = __VLS_getSlotParameters(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
         yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_: `, type, `, `] : `_, `), `) => [] as any`);

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

@@ -5,7 +5,7 @@ export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const identifierRegex: RegExp;
-export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
+export declare function collectBindingNames(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string[];
 export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
     id: ts.Identifier;
     isRest: boolean;

package/lib/codegen/utils/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.collectVars = collectVars;
+exports.collectBindingNames = collectBindingNames;
 exports.collectIdentifiers = collectIdentifiers;
 exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
@@ -11,12 +11,8 @@ exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
 exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function collectVars(ts, node, ast, results = []) {
-    const identifiers = collectIdentifiers(ts, node, []);
-    for (const { id } of identifiers) {
-        results.push((0, shared_1.getNodeText)(ts, id, ast));
-    }
-    return results;
+function collectBindingNames(ts, node, ast) {
+    return collectIdentifiers(ts, node).map(({ id }) => (0, shared_1.getNodeText)(ts, id, ast));
 }
 function collectIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
     if (ts.isIdentifier(node)) {

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

@@ -0,0 +1,3 @@
+import type { Code } from '../../types';
+export declare function generateIntersectMerge(codes: Code[]): Generator<Code>;
+export declare function generateSpreadMerge(codes: Code[]): Generator<Code>;

package/lib/codegen/utils/merge.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIntersectMerge = generateIntersectMerge;
+exports.generateSpreadMerge = generateSpreadMerge;
+const index_1 = require("./index");
+function* generateIntersectMerge(codes) {
+    yield codes[0];
+    for (let i = 1; i < codes.length; i++) {
+        yield ` & `;
+        yield codes[i];
+    }
+}
+function* generateSpreadMerge(codes) {
+    if (codes.length === 1) {
+        yield codes[0];
+    }
+    else {
+        yield `{${index_1.newLine}`;
+        for (const code of codes) {
+            yield `...`;
+            yield code;
+            yield `,${index_1.newLine}`;
+        }
+        yield `}`;
+    }
+}
+//# sourceMappingURL=merge.js.map

package/lib/parsers/scriptSetupRanges.js

@@ -147,7 +147,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 };
                 if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
                     defineProps.destructured = new Map();
-                    const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
+                    const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name);
                     for (const { id, isRest, initializer } of identifiers) {
                         const name = _getNodeText(id);
                         if (isRest) {
@@ -343,7 +343,8 @@ function findBindingVars(ts, left, ast) {
     function worker(node) {
         if (ts.isIdentifier(node)) {
             vars.push((0, shared_1.getStartEnd)(ts, node, ast));
-        } // { ? } = ...
+        }
+        // { ? } = ...
         // [ ? ] = ...
         else if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) {
             for (const property of node.elements) {
@@ -351,13 +352,16 @@ function findBindingVars(ts, left, ast) {
                     worker(property.name);
                 }
             }
-        } // { foo: ? } = ...
+        }
+        // { foo: ? } = ...
         else if (ts.isPropertyAssignment(node)) {
             worker(node.initializer);
-        } // { foo } = ...
+        }
+        // { foo } = ...
         else if (ts.isShorthandPropertyAssignment(node)) {
             vars.push((0, shared_1.getStartEnd)(ts, node.name, ast));
-        } // { ...? } = ...
+        }
+        // { ...? } = ...
         // [ ...? ] = ...
         else if (ts.isSpreadAssignment(node) || ts.isSpreadElement(node)) {
             worker(node.expression);

package/lib/plugins/file-html.js

@@ -53,7 +53,8 @@ const plugin = ({ vueCompilerOptions }) => {
                         type: 'style',
                         lang,
                     });
-                } // ignore `<script src="...">`
+                }
+                // ignore `<script src="...">`
                 else if (tag === 'script' && !attrs.includes('src=')) {
                     let type = attrs.includes('type=') ? 'scriptSetup' : 'script';
                     sfc.descriptor[type] = {

package/lib/plugins/file-md.js

@@ -9,9 +9,9 @@ const codeblockReg = /(`{3,})[\s\S]+?\1/g;
 const inlineCodeblockReg = /`[^\n`]+?`/g;
 const latexBlockReg = /(\${2,})[\s\S]+?\1/g;
 const scriptSetupReg = /\\<[\s\S]+?>\n?/g;
-const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
 const angleBracketReg = /<\S*:\S*>/g;
 const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
+const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
 const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
 const plugin = ({ vueCompilerOptions }) => {
     return {
@@ -40,42 +40,35 @@ const plugin = ({ vueCompilerOptions }) => {
                 // # \<script setup>
                 .replace(scriptSetupReg, match => ' '.repeat(match.length))
                 // <<< https://vitepress.dev/guide/markdown#import-code-snippets
-                .replace(codeSnippetImportReg, match => ' '.repeat(match.length));
-            const codes = [];
-            for (const match of content.matchAll(sfcBlockReg)) {
-                if (match.index !== undefined) {
-                    const matchText = match[0];
-                    codes.push([matchText, undefined, match.index]);
-                    codes.push('\n\n');
-                    content = content.slice(0, match.index) + ' '.repeat(matchText.length)
-                        + content.slice(match.index + matchText.length);
-                }
-            }
-            content = content
+                .replace(codeSnippetImportReg, match => ' '.repeat(match.length))
                 // angle bracket: <http://foo.com>
                 .replace(angleBracketReg, match => ' '.repeat(match.length))
                 // [foo](http://foo.com)
                 .replace(linkReg, match => ' '.repeat(match.length));
+            const codes = [];
+            for (const match of content.matchAll(sfcBlockReg)) {
+                const matchText = match[0];
+                codes.push([matchText, undefined, match.index]);
+                codes.push('\n\n');
+                content = content.slice(0, match.index) + ' '.repeat(matchText.length)
+                    + content.slice(match.index + matchText.length);
+            }
             codes.push('<template>\n');
             codes.push([content, undefined, 0]);
             codes.push('\n</template>');
-            const file2VueSourceMap = (0, language_core_1.defaultMapperFactory)((0, buildMappings_1.buildMappings)(codes));
+            const mappings = (0, buildMappings_1.buildMappings)(codes);
+            const mapper = new language_core_1.SourceMap(mappings);
             const sfc = (0, parseSfc_1.parse)((0, muggle_string_1.toString)(codes));
-            if (sfc.descriptor.template) {
-                sfc.descriptor.template.lang = 'md';
-                transformRange(sfc.descriptor.template);
-            }
-            if (sfc.descriptor.script) {
-                transformRange(sfc.descriptor.script);
-            }
-            if (sfc.descriptor.scriptSetup) {
-                transformRange(sfc.descriptor.scriptSetup);
-            }
-            for (const style of sfc.descriptor.styles) {
-                transformRange(style);
-            }
-            for (const customBlock of sfc.descriptor.customBlocks) {
-                transformRange(customBlock);
+            for (const block of [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ]) {
+                if (block) {
+                    transformRange(block);
+                }
             }
             return sfc;
             function transformRange(block) {
@@ -84,11 +77,11 @@ const plugin = ({ vueCompilerOptions }) => {
                 const endOffset = end.offset;
                 start.offset = -1;
                 end.offset = -1;
-                for (const [offset] of file2VueSourceMap.toSourceLocation(startOffset)) {
+                for (const [offset] of mapper.toSourceLocation(startOffset)) {
                     start.offset = offset;
                     break;
                 }
-                for (const [offset] of file2VueSourceMap.toSourceLocation(endOffset)) {
+                for (const [offset] of mapper.toSourceLocation(endOffset)) {
                     end.offset = offset;
                     break;
                 }

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

@@ -199,7 +199,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[]>;
         currentComponent: {
             ctxVar: string;
-            childTypes: string[];
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];

package/lib/plugins/vue-tsx.js

@@ -14,7 +14,6 @@ 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 {
         version: 2.1,
         requiredCompilerOptions: [
@@ -40,18 +39,13 @@ const plugin = ctx => {
     };
     function useCodegen(fileName, sfc) {
         if (!exports.tsCodegen.has(sfc)) {
-            let appendGlobalTypes = false;
-            if (!ctx.vueCompilerOptions.__setupedGlobalTypes && !appendedGlobalTypes) {
-                appendGlobalTypes = true;
-                appendedGlobalTypes = true;
-            }
-            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx, appendGlobalTypes));
+            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx));
         }
         return exports.tsCodegen.get(sfc);
     }
 };
 exports.default = plugin;
-function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
+function createTsx(fileName, sfc, ctx) {
     const ts = ctx.modules.typescript;
     const getRawLang = (0, alien_signals_1.computed)(() => {
         if (sfc.script && sfc.scriptSetup) {
@@ -191,7 +185,6 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
             templateCodegen: getGeneratedTemplate(),
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
-            appendGlobalTypes,
         });
         let current = codegen.next();
         while (!current.done) {

package/lib/types.d.ts

@@ -6,9 +6,10 @@ import type * as ts from 'typescript';
 import type { VueEmbeddedCode } from './virtualFile/embeddedFile';
 export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
-export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
+export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>> & {
     strictTemplates?: boolean;
     target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
+    globalTypesPath?: string;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
@@ -19,11 +20,11 @@ export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
     target: number;
     lib: string;
+    globalTypesPath: (fileName: string) => string | undefined;
     extensions: string[];
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
-    strictSlotChildren: boolean;
     strictVModel: boolean;
     strictCssModules: boolean;
     checkUnknownProps: boolean;
@@ -61,9 +62,6 @@ export interface VueCompilerOptions {
     };
     plugins: VueLanguagePlugin[];
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
-    __setupedGlobalTypes?: true | {
-        absolutePath: string;
-    };
 }
 export declare const validVersions: readonly [2, 2.1];
 export type VueLanguagePluginReturn = {

package/lib/utils/ts.d.ts

@@ -5,18 +5,19 @@ export type ParsedCommandLine = ts.ParsedCommandLine & {
 };
 export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost & {
     writeFile?(path: string, data: string): void;
-}, rootDir: string, json: any, configFileName?: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
+}, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
 export declare class CompilerOptionsResolver {
-    options: Omit<RawVueCompilerOptions, 'target' | 'plugin'>;
-    fallbackTarget: number | undefined;
+    fileExists?: ((path: string) => boolean) | undefined;
+    configRoots: Set<string>;
+    options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
     target: number | undefined;
+    globalTypesPath: string | undefined;
     plugins: VueLanguagePlugin[];
+    constructor(fileExists?: ((path: string) => boolean) | undefined);
     addConfig(options: RawVueCompilerOptions, rootDir: string): void;
     build(defaults?: VueCompilerOptions): VueCompilerOptions;
+    private findNodeModulesRoot;
 }
 export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
-export declare function setupGlobalTypes(rootDir: string, vueOptions: VueCompilerOptions, host: {
-    fileExists(path: string): boolean;
-    writeFile?(path: string, data: string): void;
-}): VueCompilerOptions['__setupedGlobalTypes'];
+export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;

package/lib/utils/ts.js

@@ -4,16 +4,16 @@ exports.CompilerOptionsResolver = void 0;
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
-exports.setupGlobalTypes = setupGlobalTypes;
+exports.writeGlobalTypes = writeGlobalTypes;
 const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("../codegen/globalTypes");
 const languagePlugin_1 = require("../languagePlugin");
 const shared_2 = require("./shared");
-function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json', skipGlobalTypesSetup = false) {
+function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json') {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
-    const resolver = new CompilerOptionsResolver();
+    const resolver = new CompilerOptionsResolver(parseConfigHost.fileExists);
     for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
         try {
             const configFile = ts.readJsonConfigFile(extendPath, proxyHost.host.readFile);
@@ -23,13 +23,9 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         }
         catch { }
     }
+    // ensure the rootDir is added to the config roots
+    resolver.addConfig({}, rootDir);
     const resolvedVueOptions = resolver.build();
-    if (skipGlobalTypesSetup) {
-        resolvedVueOptions.__setupedGlobalTypes = true;
-    }
-    else {
-        resolvedVueOptions.__setupedGlobalTypes = setupGlobalTypes(rootDir, resolvedVueOptions, parseConfigHost);
-    }
     const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
         .map(extension => ({
         extension: extension.slice(1),
@@ -45,12 +41,13 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         vueOptions: resolvedVueOptions,
     };
 }
-function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTypesSetup = false) {
+function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
     try {
+        const rootDir = path_browserify_1.posix.dirname(tsConfigPath);
         const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
         const config = ts.readJsonConfigFile(tsConfigPath, proxyHost.host.readFile);
-        ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path_browserify_1.posix.dirname(tsConfigPath), {}, tsConfigPath);
-        const resolver = new CompilerOptionsResolver();
+        ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, rootDir, {}, tsConfigPath);
+        const resolver = new CompilerOptionsResolver(parseConfigHost.fileExists);
         for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
             try {
                 const configFile = ts.readJsonConfigFile(extendPath, proxyHost.host.readFile);
@@ -61,12 +58,6 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
             catch { }
         }
         const resolvedVueOptions = resolver.build();
-        if (skipGlobalTypesSetup) {
-            resolvedVueOptions.__setupedGlobalTypes = true;
-        }
-        else {
-            resolvedVueOptions.__setupedGlobalTypes = setupGlobalTypes(path_browserify_1.posix.dirname(tsConfigPath), resolvedVueOptions, parseConfigHost);
-        }
         const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path_browserify_1.posix.dirname(tsConfigPath), {}, tsConfigPath, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
             .map(extension => ({
             extension: extension.slice(1),
@@ -113,20 +104,27 @@ function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
     };
 }
 class CompilerOptionsResolver {
-    constructor() {
+    constructor(fileExists) {
+        this.fileExists = fileExists;
+        this.configRoots = new Set();
         this.options = {};
         this.plugins = [];
     }
     addConfig(options, rootDir) {
+        this.configRoots.add(rootDir);
         for (const key in options) {
             switch (key) {
                 case 'target':
-                    const target = options.target;
-                    if (typeof target === 'string') {
+                    if (options[key] === 'auto') {
                         this.target = findVueVersion(rootDir);
                     }
                     else {
-                        this.target = target;
+                        this.target = options[key];
+                    }
+                    break;
+                case 'globalTypesPath':
+                    if (options[key] !== undefined) {
+                        this.globalTypesPath = path_browserify_1.posix.join(rootDir, options[key]);
                     }
                     break;
                 case 'plugins':
@@ -155,14 +153,13 @@ class CompilerOptionsResolver {
                     break;
             }
         }
-        if (this.target === undefined) {
-            this.fallbackTarget = findVueVersion(rootDir);
+        if (options.target === undefined) {
+            this.target ??= findVueVersion(rootDir);
         }
     }
     build(defaults) {
-        const target = this.target ?? this.fallbackTarget;
-        defaults ??= getDefaultCompilerOptions(target, this.options.lib, this.options.strictTemplates);
-        return {
+        defaults ??= getDefaultCompilerOptions(this.target, this.options.lib, this.options.strictTemplates);
+        const resolvedOptions = {
             ...defaults,
             ...this.options,
             plugins: this.plugins,
@@ -182,6 +179,35 @@ class CompilerOptionsResolver {
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
             experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
         };
+        if (this.fileExists && this.globalTypesPath === undefined) {
+            const fileDirToGlobalTypesPath = new Map();
+            resolvedOptions.globalTypesPath = fileName => {
+                const fileDir = path_browserify_1.posix.dirname(fileName);
+                if (fileDirToGlobalTypesPath.has(fileDir)) {
+                    return fileDirToGlobalTypesPath.get(fileDir);
+                }
+                const root = this.findNodeModulesRoot(fileDir, resolvedOptions.lib);
+                const result = root
+                    ? path_browserify_1.posix.join(root, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions))
+                    : undefined;
+                fileDirToGlobalTypesPath.set(fileDir, result);
+                return result;
+            };
+        }
+        else {
+            resolvedOptions.globalTypesPath = () => this.globalTypesPath;
+        }
+        return resolvedOptions;
+    }
+    findNodeModulesRoot(dir, lib) {
+        while (!this.fileExists(path_browserify_1.posix.join(dir, 'node_modules', lib, 'package.json'))) {
+            const parentDir = path_browserify_1.posix.dirname(dir);
+            if (dir === parentDir) {
+                return;
+            }
+            dir = parentDir;
+        }
+        return dir;
     }
 }
 exports.CompilerOptionsResolver = CompilerOptionsResolver;
@@ -213,11 +239,11 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
     return {
         target,
         lib,
+        globalTypesPath: () => undefined,
         extensions: ['.vue'],
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
-        strictSlotChildren: strictTemplates,
         strictVModel: strictTemplates,
         strictCssModules: false,
         checkUnknownProps: strictTemplates,
@@ -273,24 +299,19 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         },
     };
 }
-function setupGlobalTypes(rootDir, vueOptions, host) {
-    if (!host.writeFile) {
+function writeGlobalTypes(vueOptions, writeFile) {
+    const originalFn = vueOptions.globalTypesPath;
+    if (!originalFn) {
         return;
     }
-    try {
-        let dir = rootDir;
-        while (!host.fileExists(path_browserify_1.posix.join(dir, 'node_modules', vueOptions.lib, 'package.json'))) {
-            const parentDir = path_browserify_1.posix.dirname(dir);
-            if (dir === parentDir) {
-                throw 0;
-            }
-            dir = parentDir;
+    const writed = new Set();
+    vueOptions.globalTypesPath = (fileName) => {
+        const result = originalFn(fileName);
+        if (result && !writed.has(result)) {
+            writed.add(result);
+            writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));
         }
-        const globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(vueOptions));
-        const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, globalTypes_1.generateGlobalTypes)(vueOptions);
-        host.writeFile(globalTypesPath, globalTypesContents);
-        return { absolutePath: globalTypesPath };
-    }
-    catch { }
+        return result;
+    };
 }
 //# sourceMappingURL=ts.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.1",
+	"version": "3.0.3",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,19 +13,20 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.17",
+		"@volar/language-core": "2.4.20",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
 		"alien-signals": "^2.0.5",
-		"minimatch": "^10.0.1",
 		"muggle-string": "^0.4.1",
-		"path-browserify": "^1.0.1"
+		"path-browserify": "^1.0.1",
+		"picomatch": "^4.0.2"
 	},
 	"devDependencies": {
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
-		"@volar/typescript": "2.4.17",
+		"@types/picomatch": "^4.0.0",
+		"@volar/typescript": "2.4.20",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -36,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "43884409838dfdce44de51f6622926ac6ddd7318"
+	"gitHead": "129f30ff8d8d976abf0431063be5c6c4cf88f0fd"
 }