@vue/language-core 3.0.6 → 3.0.7-alpha.1

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './lib/codegen/globalTypes';
 export * from './lib/codegen/template';
+export * from './lib/compilerOptions';
 export * from './lib/languagePlugin';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
@@ -7,7 +8,6 @@ export * from './lib/types';
 export * from './lib/utils/collectBindings';
 export * from './lib/utils/parseSfc';
 export * from './lib/utils/shared';
-export * from './lib/utils/ts';
 export * from './lib/virtualFile/vueFile';
 export { tsCodegen } from './lib/plugins/vue-tsx';
 export * from '@volar/language-core';

package/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 __exportStar(require("./lib/codegen/globalTypes"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
+__exportStar(require("./lib/compilerOptions"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);
 __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
@@ -24,7 +25,6 @@ __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/utils/collectBindings"), exports);
 __exportStar(require("./lib/utils/parseSfc"), exports);
 __exportStar(require("./lib/utils/shared"), exports);
-__exportStar(require("./lib/utils/ts"), exports);
 __exportStar(require("./lib/virtualFile/vueFile"), exports);
 var vue_tsx_1 = require("./lib/plugins/vue-tsx");
 Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });

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

@@ -3,8 +3,6 @@ import type { ScriptRanges } from '../../parsers/scriptRanges';
 import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
-import { type ScriptCodegenContext } from './context';
-export * from './context';
 export interface ScriptCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;
@@ -20,5 +18,24 @@ export interface ScriptCodegenOptions {
     destructuredPropNames: Set<string>;
     templateRefNames: Set<string>;
 }
-export declare function generateScript(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;
+export { generate as generateScript };
+declare function generate(options: ScriptCodegenOptions): {
+    codes: Code[];
+    generatedTemplate: boolean;
+    generatedPropsType: boolean;
+    bypassDefineComponent: boolean;
+    bindingNames: Set<string>;
+    localTypes: {
+        generate: (names: string[]) => Generator<string, void, unknown>;
+        getUsedNames(): Set<string>;
+        readonly PrettifyLocal: string;
+        readonly OmitKeepDiscriminatedUnion: string;
+        readonly WithDefaults: string;
+        readonly WithSlots: string;
+        readonly PropsChildren: string;
+        readonly TypePropsToOption: string;
+        readonly OmitIndexSignature: string;
+    };
+    inlayHints: import("../inlayHints").InlayHintInfo[];
+};
 export declare function generateScriptSectionPartiallyEnding(source: string, end: number, mark: string, delimiter?: string): Generator<Code>;

package/lib/codegen/script/index.js

@@ -1,29 +1,23 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateScript = generateScript;
+exports.generateScript = generate;
 exports.generateScriptSectionPartiallyEnding = generateScriptSectionPartiallyEnding;
 const path = require("path-browserify");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const componentSelf_1 = require("./componentSelf");
+const context_1 = require("./context");
 const scriptSetup_1 = require("./scriptSetup");
 const src_1 = require("./src");
 const template_1 = require("./template");
-__exportStar(require("./context"), exports);
+function generate(options) {
+    const context = (0, context_1.createScriptCodegenContext)(options);
+    const codegen = generateScript(options, context);
+    return {
+        ...context,
+        codes: [...codegen],
+    };
+}
 function* generateScript(options, ctx) {
     yield* generateGlobalTypesPath(options);
     if (options.sfc.script?.src) {

package/lib/codegen/template/elementDirectives.js

@@ -29,7 +29,9 @@ function* generateElementDirectives(options, ctx, node) {
             || prop.name === 'bind') {
             continue;
         }
-        ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
+        if (!builtInDirectives.has(prop.name)) {
+            ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
+        }
         yield* (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, codeFeatures_1.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(options, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), ` }, null!, null!)`);
         yield utils_1.endOfLine;
     }

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

@@ -1,8 +1,6 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
-import type { TemplateCodegenContext } from './context';
-export * from './context';
 export interface TemplateCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;
@@ -18,5 +16,67 @@ export interface TemplateCodegenOptions {
     inheritAttrs: boolean;
     selfComponentName?: string;
 }
-export declare function generateTemplate(options: TemplateCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;
+export { generate as generateTemplate };
+declare function generate(options: TemplateCodegenOptions): {
+    codes: Code[];
+    currentInfo: {
+        ignoreError?: boolean;
+        expectError?: {
+            token: number;
+            node: CompilerDOM.CommentNode;
+        };
+        generic?: {
+            content: string;
+            offset: number;
+        };
+    };
+    resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
+    inlineTsAsts: Map<string, ts.SourceFile> | undefined;
+    inVFor: boolean;
+    slots: {
+        name: string;
+        offset?: number;
+        tagRange: [number, number];
+        nodeLoc: any;
+        propsVar: string;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        propsVar: string;
+    }[];
+    dollarVars: Set<string>;
+    accessExternalVariables: Map<string, Set<number>>;
+    blockConditions: string[];
+    scopedClasses: {
+        source: string;
+        className: string;
+        offset: number;
+    }[];
+    emptyClassOffsets: number[];
+    inlayHints: import("../inlayHints").InlayHintInfo[];
+    bindingAttrLocs: CompilerDOM.SourceLocation[];
+    inheritedAttrVars: Set<string>;
+    templateRefs: Map<string, {
+        typeExp: string;
+        offset: number;
+    }[]>;
+    currentComponent: {
+        ctxVar: string;
+        used: boolean;
+    } | undefined;
+    singleRootElTypes: string[];
+    singleRootNodes: Set<CompilerDOM.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>;
+    generateAutoImportCompletion(): Generator<Code>;
+    enter(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): boolean;
+    exit(): Generator<Code>;
+};
 export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;

package/lib/codegen/template/index.js

@@ -1,30 +1,31 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTemplate = generateTemplate;
+exports.generateTemplate = generate;
 exports.forEachElementNode = forEachElementNode;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
+const context_1 = require("./context");
 const objectProperty_1 = require("./objectProperty");
 const styleScopedClasses_1 = require("./styleScopedClasses");
 const templateChild_1 = require("./templateChild");
-__exportStar(require("./context"), exports);
+function generate(options) {
+    const context = (0, context_1.createTemplateCodegenContext)(options, options.template.ast);
+    const codegen = generateTemplate(options, context);
+    const codes = [];
+    for (const code of codegen) {
+        if (typeof code === 'object') {
+            code[3] = context.resolveCodeFeatures(code[3]);
+        }
+        codes.push(code);
+    }
+    return {
+        ...context,
+        codes,
+    };
+}
 function* generateTemplate(options, ctx) {
     if (options.slotsAssignName) {
         ctx.addLocalVariable(options.slotsAssignName);

package/lib/codegen/template/interpolation.js

@@ -140,8 +140,13 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
             ctx.addLocalVariable(name);
             blockVars.push(name);
         }
-        if (node.initializer) {
-            walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars);
+        walkIdentifiersInBinding(ts, node, ast, cb, ctx, blockVars);
+    }
+    else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
+        for (const element of node.elements) {
+            if (ts.isBindingElement(element)) {
+                walkIdentifiersInBinding(ts, element, ast, cb, ctx, blockVars);
+            }
         }
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
@@ -194,13 +199,22 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
         }
     }
 }
+function walkIdentifiersInBinding(ts, node, ast, cb, ctx, blockVars) {
+    if ('type' in node && node.type) {
+        walkIdentifiersInTypeNode(ts, node.type, cb);
+    }
+    if (!ts.isIdentifier(node.name)) {
+        walkIdentifiers(ts, node.name, ast, cb, ctx, blockVars);
+    }
+    if (node.initializer) {
+        walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars);
+    }
+}
 function walkIdentifiersInFunction(ts, node, ast, cb, ctx) {
     const functionArgs = [];
     for (const param of node.parameters) {
         functionArgs.push(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
-        if (param.type) {
-            walkIdentifiersInTypeNode(ts, param.type, cb);
-        }
+        walkIdentifiersInBinding(ts, param, ast, cb, ctx, functionArgs);
     }
     for (const varName of functionArgs) {
         ctx.addLocalVariable(varName);

package/lib/codegen/template/vSlot.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVSlot = generateVSlot;
 const CompilerDOM = require("@vue/compiler-dom");
+const muggle_string_1 = require("muggle-string");
 const collectBindings_1 = require("../../utils/collectBindings");
-const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
 const elementChildren_1 = require("./elementChildren");
+const interpolation_1 = require("./interpolation");
 const objectProperty_1 = require("./objectProperty");
 function* generateVSlot(options, ctx, node, slotDir) {
     if (!ctx.currentComponent) {
@@ -38,7 +39,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}) => {}`);
         slotBlockVars.push(...(0, collectBindings_1.collectBindingNames)(options.ts, slotAst, slotAst));
-        yield* generateSlotParameters(options, slotAst, slotDir.exp, slotVar);
+        yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
     }
     for (const varName of slotBlockVars) {
         ctx.addLocalVariable(varName);
@@ -69,7 +70,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield `}${utils_1.newLine}`;
     }
 }
-function* generateSlotParameters(options, ast, exp, slotVar) {
+function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     const { ts } = options;
     const statement = ast.statements[0];
     if (!ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
@@ -77,42 +78,31 @@ function* generateSlotParameters(options, ast, exp, slotVar) {
     }
     const { expression } = statement;
     const startOffset = exp.loc.start.offset - 1;
-    const modifies = [];
     const types = [];
+    const interpolation = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, ast.text, startOffset)];
+    (0, muggle_string_1.replaceSourceRange)(interpolation, 'template', startOffset, startOffset + `(`.length);
+    (0, muggle_string_1.replaceSourceRange)(interpolation, 'template', startOffset + ast.text.length - `) => {}`.length, startOffset + ast.text.length);
     for (const { name, type } of expression.parameters) {
         if (type) {
-            modifies.push([
-                [``],
-                name.end,
-                type.end,
+            types.push([
+                ast.text.slice(name.end, type.end),
+                'template',
+                startOffset + name.end,
+                codeFeatures_1.codeFeatures.all,
             ]);
-            types.push(chunk((0, shared_1.getStartEnd)(ts, type, ast).start, type.end));
+            (0, muggle_string_1.replaceSourceRange)(interpolation, 'template', startOffset + name.end, startOffset + type.end);
         }
         else {
             types.push(null);
         }
     }
     yield `const [`;
-    let nextStart = 1;
-    for (const [codes, start, end] of modifies) {
-        yield chunk(nextStart, start);
-        yield* codes;
-        nextStart = end;
-    }
-    yield chunk(nextStart, expression.equalsGreaterThanToken.pos - 1);
+    yield* interpolation;
     yield `] = __VLS_getSlotParameters(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
-        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_: `, type, `, `] : `_, `), `) => [] as any`);
+        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_`, type, `, `] : `_, `), `) => [] as any`);
     }
     yield `)${utils_1.endOfLine}`;
-    function chunk(start, end) {
-        return [
-            ast.text.slice(start, end),
-            'template',
-            startOffset + start,
-            codeFeatures_1.codeFeatures.all,
-        ];
-    }
 }
 //# sourceMappingURL=vSlot.js.map

package/lib/{utils/ts.d.ts → compilerOptions.d.ts}

@@ -1,5 +1,5 @@
 import type * as ts from 'typescript';
-import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from '../types';
+import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from './types';
 interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
 }
 export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
@@ -9,7 +9,6 @@ export declare function createParsedCommandLineByJson(ts: typeof import('typescr
 export declare function createParsedCommandLine(ts: typeof import('typescript'), host: ParseConfigHost, configFileName: string): ParsedCommandLine;
 export declare class CompilerOptionsResolver {
     fileExists?: ((path: string) => boolean) | undefined;
-    configRoots: Set<string>;
     options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
     target: number | undefined;
     globalTypesPath: string | undefined;

package/lib/compilerOptions.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerOptionsResolver = void 0;
+exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
+exports.createParsedCommandLine = createParsedCommandLine;
+exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
+exports.writeGlobalTypes = writeGlobalTypes;
+const shared_1 = require("@vue/shared");
+const path_browserify_1 = require("path-browserify");
+const globalTypes_1 = require("./codegen/globalTypes");
+const shared_2 = require("./utils/shared");
+function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
+    const extendedPaths = new Set();
+    const proxyHost = {
+        ...host,
+        readFile(fileName) {
+            if (!fileName.endsWith('/package.json')) {
+                extendedPaths.add(fileName);
+            }
+            return host.readFile(fileName);
+        },
+        readDirectory() {
+            return [];
+        },
+    };
+    const parsed = ts.parseJsonConfigFileContent(json, proxyHost, rootDir, {}, configFileName);
+    const resolver = new CompilerOptionsResolver(host.fileExists);
+    for (const extendPath of [...extendedPaths].reverse()) {
+        try {
+            const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+            const obj = ts.convertToObject(configFile, []);
+            const rawOptions = obj?.vueCompilerOptions ?? {};
+            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+        }
+        catch { }
+    }
+    // ensure the rootDir is added to the config roots
+    resolver.addConfig({}, rootDir);
+    return {
+        ...parsed,
+        vueOptions: resolver.build(),
+    };
+}
+function createParsedCommandLine(ts, host, configFileName) {
+    try {
+        const extendedPaths = new Set();
+        const proxyHost = {
+            ...host,
+            readFile(fileName) {
+                if (!fileName.endsWith('/package.json')) {
+                    extendedPaths.add(fileName);
+                }
+                return host.readFile(fileName);
+            },
+            readDirectory() {
+                return [];
+            },
+        };
+        const config = ts.readJsonConfigFile(configFileName, proxyHost.readFile);
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
+        const resolver = new CompilerOptionsResolver(host.fileExists);
+        for (const extendPath of [...extendedPaths].reverse()) {
+            try {
+                const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+                const obj = ts.convertToObject(configFile, []);
+                const rawOptions = obj?.vueCompilerOptions ?? {};
+                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+            }
+            catch { }
+        }
+        return {
+            ...parsed,
+            vueOptions: resolver.build(),
+        };
+    }
+    catch { }
+    return {
+        options: {},
+        errors: [],
+        vueOptions: getDefaultCompilerOptions(),
+    };
+}
+class CompilerOptionsResolver {
+    constructor(fileExists) {
+        this.fileExists = fileExists;
+        this.options = {};
+        this.plugins = [];
+    }
+    addConfig(options, rootDir) {
+        for (const key in options) {
+            switch (key) {
+                case 'target':
+                    if (options[key] === 'auto') {
+                        this.target = findVueVersion(rootDir);
+                    }
+                    else {
+                        this.target = options[key];
+                    }
+                    break;
+                case 'globalTypesPath':
+                    if (options[key] !== undefined) {
+                        this.globalTypesPath = path_browserify_1.posix.join(rootDir, options[key]);
+                    }
+                    break;
+                case 'plugins':
+                    this.plugins = (options.plugins ?? [])
+                        .flatMap((pluginPath) => {
+                        try {
+                            const resolvedPath = resolvePath(pluginPath, rootDir);
+                            if (resolvedPath) {
+                                const plugin = require(resolvedPath);
+                                plugin.__moduleName = pluginPath;
+                                return plugin;
+                            }
+                            else {
+                                console.warn('[Vue] Load plugin failed:', pluginPath);
+                            }
+                        }
+                        catch (error) {
+                            console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
+                        }
+                        return [];
+                    });
+                    break;
+                default:
+                    // @ts-expect-error
+                    this.options[key] = options[key];
+                    break;
+            }
+        }
+        if (options.target === undefined) {
+            this.target ??= findVueVersion(rootDir);
+        }
+    }
+    build(defaults) {
+        defaults ??= getDefaultCompilerOptions(this.target, this.options.lib, this.options.strictTemplates);
+        const resolvedOptions = {
+            ...defaults,
+            ...this.options,
+            plugins: this.plugins,
+            macros: {
+                ...defaults.macros,
+                ...this.options.macros,
+            },
+            composables: {
+                ...defaults.composables,
+                ...this.options.composables,
+            },
+            fallthroughComponentNames: [
+                ...defaults.fallthroughComponentNames,
+                ...this.options.fallthroughComponentNames ?? [],
+            ].map(shared_2.hyphenateTag),
+            // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
+            // 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 (resolvedOptions.globalTypesPath === shared_1.NOOP) {
+            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;
+function findVueVersion(rootDir) {
+    const resolvedPath = resolvePath('vue/package.json', rootDir);
+    if (resolvedPath) {
+        const vuePackageJson = require(resolvedPath);
+        const versionNumbers = vuePackageJson.version.split('.');
+        return Number(versionNumbers[0] + '.' + versionNumbers[1]);
+    }
+    else {
+        // console.warn('Load vue/package.json failed from', folder);
+    }
+}
+function resolvePath(scriptPath, root) {
+    try {
+        if (require?.resolve) {
+            return require.resolve(scriptPath, { paths: [root] });
+        }
+        else {
+            // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
+        }
+    }
+    catch {
+        // console.warn(error);
+    }
+}
+function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false) {
+    return {
+        target,
+        lib,
+        globalTypesPath: shared_1.NOOP,
+        extensions: ['.vue'],
+        vitePressExtensions: [],
+        petiteVueExtensions: [],
+        jsxSlots: false,
+        strictVModel: strictTemplates,
+        strictCssModules: false,
+        checkUnknownProps: strictTemplates,
+        checkUnknownEvents: strictTemplates,
+        checkUnknownDirectives: strictTemplates,
+        checkUnknownComponents: strictTemplates,
+        inferComponentDollarEl: false,
+        inferComponentDollarRefs: false,
+        inferTemplateDollarAttrs: false,
+        inferTemplateDollarEl: false,
+        inferTemplateDollarRefs: false,
+        inferTemplateDollarSlots: false,
+        skipTemplateCodegen: false,
+        fallthroughAttributes: false,
+        resolveStyleImports: false,
+        resolveStyleClassNames: 'scoped',
+        fallthroughComponentNames: [
+            'Transition',
+            'KeepAlive',
+            'Teleport',
+            'Suspense',
+        ],
+        dataAttributes: [],
+        htmlAttributes: ['aria-*'],
+        optionsWrapper: target >= 2.7
+            ? [`(await import('${lib}')).defineComponent(`, `)`]
+            : [`(await import('${lib}')).default.extend(`, `)`],
+        macros: {
+            defineProps: ['defineProps'],
+            defineSlots: ['defineSlots'],
+            defineEmits: ['defineEmits'],
+            defineExpose: ['defineExpose'],
+            defineModel: ['defineModel'],
+            defineOptions: ['defineOptions'],
+            withDefaults: ['withDefaults'],
+        },
+        composables: {
+            useAttrs: ['useAttrs'],
+            useCssModule: ['useCssModule'],
+            useSlots: ['useSlots'],
+            useTemplateRef: ['useTemplateRef', 'templateRef'],
+        },
+        plugins: [],
+        experimentalModelPropName: {
+            '': {
+                input: true,
+            },
+            value: {
+                input: { type: 'text' },
+                textarea: true,
+                select: true,
+            },
+        },
+    };
+}
+function writeGlobalTypes(vueOptions, writeFile) {
+    const originalFn = vueOptions.globalTypesPath;
+    if (!originalFn) {
+        return;
+    }
+    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));
+        }
+        return result;
+    };
+}
+//# sourceMappingURL=compilerOptions.js.map

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

@@ -1,4 +1,4 @@
-import type { Code, Sfc, VueLanguagePlugin } from '../types';
+import type { Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
     getLang: () => string;
     getScriptRanges: () => {
@@ -118,7 +118,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
     } | undefined;
     getSetupSlotsAssignName: () => string | undefined;
     getGeneratedScript: () => {
-        codes: Code[];
+        codes: import("../types").Code[];
         generatedTemplate: boolean;
         generatedPropsType: boolean;
         bypassDefineComponent: boolean;
@@ -137,7 +137,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
     };
     getGeneratedTemplate: () => {
-        codes: Code[];
+        codes: import("../types").Code[];
         currentInfo: {
             ignoreError?: boolean;
             expectError?: {
@@ -194,9 +194,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
         getHoistVariable(originalVar: string): string;
         generateHoistVariables(): Generator<string, void, unknown>;
         generateConditionGuards(): Generator<string, void, unknown>;
-        generateAutoImportCompletion(): Generator<Code>;
+        generateAutoImportCompletion(): Generator<import("../types").Code>;
         enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
-        exit(): Generator<Code>;
+        exit(): Generator<import("../types").Code>;
     } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;

package/lib/plugins/vue-tsx.js

@@ -6,11 +6,11 @@ const alien_signals_1 = require("alien-signals");
 const path = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
+const compilerOptions_1 = require("../compilerOptions");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 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 => {
@@ -68,7 +68,7 @@ function createTsx(fileName, sfc, ctx) {
     const getResolvedOptions = (0, alien_signals_1.computed)(() => {
         const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
         if (options) {
-            const resolver = new ts_1.CompilerOptionsResolver();
+            const resolver = new compilerOptions_1.CompilerOptionsResolver();
             resolver.addConfig(options, path.dirname(fileName));
             return resolver.build(ctx.vueCompilerOptions);
         }
@@ -144,7 +144,7 @@ function createTsx(fileName, sfc, ctx) {
         if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
             return;
         }
-        const options = {
+        return (0, template_1.generateTemplate)({
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
@@ -158,23 +158,10 @@ function createTsx(fileName, sfc, ctx) {
             propsAssignName: getSetupPropsAssignName(),
             inheritAttrs: getSetupInheritAttrs(),
             selfComponentName: getComponentSelfName(),
-        };
-        const context = (0, template_1.createTemplateCodegenContext)(options, sfc.template.ast);
-        const codegen = (0, template_1.generateTemplate)(options, context);
-        const codes = [];
-        for (const code of codegen) {
-            if (typeof code === 'object') {
-                code[3] = context.resolveCodeFeatures(code[3]);
-            }
-            codes.push(code);
-        }
-        return {
-            ...context,
-            codes,
-        };
+        });
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
-        const options = {
+        return (0, script_1.generateScript)({
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
@@ -186,13 +173,7 @@ function createTsx(fileName, sfc, ctx) {
             templateCodegen: getGeneratedTemplate(),
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
-        };
-        const context = (0, script_1.createScriptCodegenContext)(options);
-        const codegen = (0, script_1.generateScript)(options, context);
-        return {
-            ...context,
-            codes: [...codegen],
-        };
+        });
     });
     return {
         getLang,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.6",
+	"version": "3.0.7-alpha.1",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "59f8cde8a5148e54294868104312b2b0f4c30d1e"
+	"gitHead": "320fc626c871e9ff17c0e4e92ea7ddb0c7641f34"
 }