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

package/lib/codegen/script/componentSelf.js

@@ -32,7 +32,7 @@ function* generateComponentSelf(options, ctx, templateCodegenCtx) {
             yield `${varName},${utils_1.newLine}`;
         }
         yield `}),${utils_1.newLine}`;
-        if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
+        if (!ctx.bypassDefineComponent) {
             const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.scriptSetupRanges)];
             yield* emitOptionCodes;
             yield* (0, component_1.generatePropsOption)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges, !!emitOptionCodes.length, false);

package/lib/codegen/script/index.js

@@ -47,9 +47,7 @@ function* generateScript(options, ctx) {
                 blockName: options.sfc.script.name,
                 offset: exportDefault.expression.start,
                 setting: 'vue.inlayHints.optionsWrapper',
-                label: options.vueCompilerOptions.optionsWrapper.length
-                    ? options.vueCompilerOptions.optionsWrapper[0]
-                    : '[Missing optionsWrapper[0]]',
+                label: options.vueCompilerOptions.optionsWrapper[0],
                 tooltip: [
                     'This is virtual code that is automatically wrapped for type support, it does not affect your runtime behavior, you can customize it via `vueCompilerOptions.optionsWrapper` option in tsconfig / jsconfig.',
                     'To hide it, you can set `"vue.inlayHints.optionsWrapper": false` in IDE settings.',
@@ -58,9 +56,7 @@ function* generateScript(options, ctx) {
                 blockName: options.sfc.script.name,
                 offset: exportDefault.expression.end,
                 setting: 'vue.inlayHints.optionsWrapper',
-                label: options.vueCompilerOptions.optionsWrapper.length >= 2
-                    ? options.vueCompilerOptions.optionsWrapper[1]
-                    : '[Missing optionsWrapper[1]]',
+                label: options.vueCompilerOptions.optionsWrapper[1],
             });
             yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, codeFeatures_1.codeFeatures.all);
             yield options.vueCompilerOptions.optionsWrapper[0];

package/lib/codegen/script/scriptSetup.js

@@ -97,7 +97,7 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
                 [
                     `let __VLS_exposed!: `,
                     (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, codeFeatures_1.codeFeatures.all),
-                    `${utils_1.endOfLine}`,
+                    utils_1.endOfLine,
                 ],
                 callExp.start,
                 callExp.start,
@@ -112,7 +112,7 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
                 [
                     `const __VLS_exposed = `,
                     (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.all),
-                    `${utils_1.endOfLine}`,
+                    utils_1.endOfLine,
                 ],
                 callExp.start,
                 callExp.start,

package/lib/codegen/template/element.js

@@ -110,7 +110,7 @@ function* generateComponent(options, ctx, node) {
                 ? codeFeatures_1.codeFeatures.verification
                 : codeFeatures_1.codeFeatures.doNotReportTs2339AndTs2551,
         });
-        yield `${utils_1.endOfLine}`;
+        yield utils_1.endOfLine;
         const camelizedTag = (0, shared_1.camelize)(node.tag);
         if (utils_1.identifierRegex.test(camelizedTag)) {
             // navigation support
@@ -131,7 +131,7 @@ function* generateComponent(options, ctx, node) {
                     onlyImport: true,
                 },
             });
-            yield `${utils_1.endOfLine}`;
+            yield utils_1.endOfLine;
         }
     }
     yield `// @ts-ignore${utils_1.newLine}`;
@@ -159,7 +159,7 @@ function* generateComponent(options, ctx, node) {
         if (ctx.inVFor) {
             yield `[]`;
         }
-        yield `${utils_1.endOfLine}`;
+        yield utils_1.endOfLine;
         if (refName && offset) {
             ctx.addTemplateRef(refName, `typeof ${ctx.getHoistVariable(componentInstanceVar)}`, offset);
         }

package/lib/codegen/template/elementProps.js

@@ -138,8 +138,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             }
             yield `,${utils_1.newLine}`;
         }
-        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.name === 'bind'
+        else if (prop.name === 'bind'
             && !prop.arg
             && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             if (prop.exp.loc.source === '$attrs') {
@@ -172,8 +171,8 @@ function* generatePropExp(options, ctx, prop, exp, enableCodeFeatures = true) {
         else {
             const propVariableName = (0, shared_1.camelize)(exp.loc.source);
             if (utils_1.identifierRegex.test(propVariableName)) {
-                const isDestructuredProp = options.destructuredPropNames?.has(propVariableName) ?? false;
-                const isTemplateRef = options.templateRefNames?.has(propVariableName) ?? false;
+                const isDestructuredProp = options.destructuredPropNames.has(propVariableName);
+                const isTemplateRef = options.templateRefNames.has(propVariableName);
                 const codes = (0, camelized_1.generateCamelized)(exp.loc.source, 'template', exp.loc.start.offset, features);
                 if (ctx.hasLocalVariable(propVariableName) || isDestructuredProp) {
                     yield* codes;
@@ -216,7 +215,7 @@ function* generateAttrValue(attrNode, features) {
 function getShouldCamelize(options, prop, propName) {
     return (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
         || !prop.arg
-        || (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))
+        || (prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))
         && (0, shared_2.hyphenateAttr)(propName) === propName
         && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, picomatch_1.isMatch)(propName, pattern));
 }

package/lib/codegen/template/index.js

@@ -79,7 +79,7 @@ function* generateSlots(options, ctx) {
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }
-        yield `${utils_1.endOfLine}`;
+        yield utils_1.endOfLine;
     }
     return `__VLS_Slots`;
 }
@@ -160,8 +160,7 @@ function* forEachElementNode(node) {
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else
-        for (let i = 0; i < node.branches.length; i++) {
-            const branch = node.branches[i];
+        for (const branch of node.branches) {
             for (const childNode of branch.children) {
                 yield* forEachElementNode(childNode);
             }

package/lib/codegen/template/slotOutlet.js

@@ -19,8 +19,7 @@ function* generateSlotOutlet(options, ctx, node) {
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
             return prop.name === 'name';
         }
-        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.name === 'bind'
+        if (prop.name === 'bind'
             && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             return prop.arg.content === 'name';
         }
@@ -48,7 +47,7 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}`, ...codes);
+            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, options.slotsAssignName ?? '__VLS_slots', ...codes);
         }
         else {
             yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);

package/lib/codegen/template/styleScopedClasses.js

@@ -47,10 +47,9 @@ function collectStyleScopedClassReferences(options, ctx, node) {
                 }
             }
             else {
-                let isWrapped = false;
                 const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
                 if (content) {
-                    const classes = collectClasses(content, startOffset + (isWrapped ? 1 : 0));
+                    const classes = collectClasses(content, startOffset);
                     ctx.scopedClasses.push(...classes);
                 }
                 else {

package/lib/codegen/template/vFor.js

@@ -40,7 +40,7 @@ function* generateVFor(options, ctx, node) {
     for (const argument of node.codegenNode?.children.arguments ?? []) {
         if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
             && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
-            && argument.returns?.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
+            && argument.returns.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
             if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
                 isFragment = false;
                 continue;

package/lib/codegen/template/vSlot.js

@@ -73,7 +73,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
 function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     const { ts } = options;
     const statement = ast.statements[0];
-    if (!ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
+    if (!statement || !ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
         return;
     }
     const { expression } = statement;

package/lib/compilerOptions.js

@@ -277,13 +277,10 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
     };
 }
 function writeGlobalTypes(vueOptions, writeFile) {
-    const originalFn = vueOptions.globalTypesPath;
-    if (!originalFn) {
-        return;
-    }
     const writed = new Set();
+    const { globalTypesPath } = vueOptions;
     vueOptions.globalTypesPath = (fileName) => {
-        const result = originalFn(fileName);
+        const result = globalTypesPath(fileName);
         if (result && !writed.has(result)) {
             writed.add(result);
             writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));

package/lib/parsers/scriptRanges.js

@@ -60,7 +60,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup) {
         }
         if (ts.isClassDeclaration(raw)
             && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)
-            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
+            && raw.modifiers.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
             classBlockEnd = raw.end - 1;
         }
     });

package/lib/parsers/scriptSetupRanges.js

@@ -335,8 +335,8 @@ function parseBindingRanges(ts, ast) {
 function getStatementRange(ts, parents, node, ast) {
     let statementRange;
     for (let i = parents.length - 1; i >= 0; i--) {
-        if (ts.isStatement(parents[i])) {
-            const statement = parents[i];
+        const statement = parents[i];
+        if (ts.isStatement(statement)) {
             ts.forEachChild(statement, child => {
                 const range = (0, shared_1.getStartEnd)(ts, child, ast);
                 statementRange ??= range;

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

@@ -59,7 +59,7 @@ const plugin = ctx => {
             return data;
         }
         const templateContent = sfc.template.content;
-        const inlineTsAsts = sfc.template.ast && computedSfc_1.templateInlineTsAsts.get(sfc.template.ast);
+        const inlineTsAsts = computedSfc_1.templateInlineTsAsts.get(sfc.template.ast);
         let i = 0;
         sfc.template.ast.children.forEach(visit);
         return data;
@@ -120,8 +120,7 @@ const plugin = ctx => {
                 }
             }
             else if (node.type === CompilerDOM.NodeTypes.IF) {
-                for (let i = 0; i < node.branches.length; i++) {
-                    const branch = node.branches[i];
+                for (const branch of node.branches) {
                     if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                         addFormatCodes(branch.condition.loc.source, branch.condition.loc.start.offset, formatBrackets.if);
                     }

package/lib/plugins/vue-tsx.js

@@ -31,9 +31,7 @@ const plugin = ctx => {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
                 const codegen = useCodegen(fileName, sfc);
                 const tsx = codegen.getGeneratedScript();
-                if (tsx) {
-                    embeddedFile.content = [...tsx.codes];
-                }
+                embeddedFile.content = [...tsx.codes];
             }
         },
     };

package/lib/utils/shared.d.ts

@@ -4,6 +4,6 @@ import type { Sfc, TextRange } from '../types';
 export { hyphenate as hyphenateTag } from '@vue/shared';
 export declare function hyphenateAttr(str: string): string;
 export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";
-export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): number[];
+export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): [number] | [number, number];
 export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
 export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;

package/lib/utils/vue2TemplateCompiler.js

@@ -31,7 +31,7 @@ const compile = (template, options = {}) => {
             loc: {
                 source: '',
                 start: { column: -1, line: -1, offset: error.start },
-                end: { column: -1, line: -1, offset: error.end ?? error.start },
+                end: { column: -1, line: -1, offset: error.end },
             },
         });
     }
@@ -43,7 +43,7 @@ const compile = (template, options = {}) => {
             loc: {
                 source: '',
                 start: { column: -1, line: -1, offset: error.start },
-                end: { column: -1, line: -1, offset: error.end ?? error.start },
+                end: { column: -1, line: -1, offset: error.end },
             },
         });
     }

package/lib/virtualFile/computedSfc.js

@@ -18,7 +18,7 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     const getComments = (0, alien_signals_1.computed)(oldValue => {
         const newValue = getParseResult()?.descriptor.comments ?? [];
         if (oldValue?.length === newValue.length
-            && oldValue?.every((v, i) => v === newValue[i])) {
+            && oldValue.every((v, i) => v === newValue[i])) {
             return oldValue;
         }
         return newValue;
@@ -27,13 +27,13 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
         const compiledAst = computedTemplateAst(base);
         return mergeObject(base, {
             get ast() {
-                return compiledAst()?.ast;
+                return compiledAst().ast;
             },
             get errors() {
-                return compiledAst()?.errors;
+                return compiledAst().errors;
             },
             get warnings() {
-                return compiledAst()?.warnings;
+                return compiledAst().warnings;
             },
         });
     });

package/lib/virtualFile/vueFile.d.ts

@@ -1,6 +1,7 @@
-import type { VirtualCode } from '@volar/language-core';
+import type { CodeInformation, Mapping, VirtualCode } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions, VueLanguagePluginReturn } from '../types';
+import { computedSfc } from './computedSfc';
 export declare class VueVirtualCode implements VirtualCode {
     fileName: string;
     languageId: string;
@@ -8,22 +9,16 @@ export declare class VueVirtualCode implements VirtualCode {
     vueCompilerOptions: VueCompilerOptions;
     plugins: VueLanguagePluginReturn[];
     ts: typeof import('typescript');
-    id: string;
+    readonly id = "main";
+    readonly sfc: ReturnType<typeof computedSfc>;
     private _snapshot;
     private _vueSfc;
-    private _sfc;
     private _embeddedCodes;
     private _mappings;
     get snapshot(): ts.IScriptSnapshot;
     get vueSfc(): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    get sfc(): import("../types").Sfc;
     get embeddedCodes(): VirtualCode[];
-    get mappings(): {
-        sourceOffsets: number[];
-        generatedOffsets: number[];
-        lengths: number[];
-        data: import("@volar/language-core").CodeInformation;
-    }[];
+    get mappings(): Mapping<CodeInformation>[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: VueLanguagePluginReturn[], ts: typeof import('typescript'));
     update(newSnapshot: ts.IScriptSnapshot): void;
 }

package/lib/virtualFile/vueFile.js

@@ -7,16 +7,12 @@ const computedEmbeddedCodes_1 = require("./computedEmbeddedCodes");
 const computedSfc_1 = require("./computedSfc");
 const computedVueSfc_1 = require("./computedVueSfc");
 class VueVirtualCode {
-    // others
     get snapshot() {
         return this._snapshot();
     }
     get vueSfc() {
         return this._vueSfc();
     }
-    get sfc() {
-        return this._sfc;
-    }
     get embeddedCodes() {
         return this._embeddedCodes();
     }
@@ -30,13 +26,11 @@ class VueVirtualCode {
         this.vueCompilerOptions = vueCompilerOptions;
         this.plugins = plugins;
         this.ts = ts;
-        // sources
         this.id = 'main';
-        this._snapshot = (0, alien_signals_1.signal)(undefined);
-        // computeds
+        this._snapshot = (0, alien_signals_1.signal)(initSnapshot);
         this._vueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, this.languageId, this._snapshot);
-        this._sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, this._snapshot, this._vueSfc);
-        this._embeddedCodes = (0, computedEmbeddedCodes_1.computedEmbeddedCodes)(this.plugins, this.fileName, this._sfc);
+        this.sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, this._snapshot, this._vueSfc);
+        this._embeddedCodes = (0, computedEmbeddedCodes_1.computedEmbeddedCodes)(this.plugins, this.fileName, this.sfc);
         this._mappings = (0, alien_signals_1.computed)(() => {
             const snapshot = this._snapshot();
             return [{
@@ -46,7 +40,6 @@ class VueVirtualCode {
                     data: plugins_1.allCodeFeatures,
                 }];
         });
-        this._snapshot(initSnapshot);
     }
     update(newSnapshot) {
         this._snapshot(newSnapshot);

package/package.json

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

package/lib/utils/ts.js

@@ -1,296 +0,0 @@
-"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("./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.configRoots = new Set();
-        this.options = {};
-        this.plugins = [];
-    }
-    addConfig(options, rootDir) {
-        this.configRoots.add(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=ts.js.map