@vue/language-core 3.0.5 → 3.0.7-alpha.0

package/lib/codegen/template/styleScopedClasses.js

@@ -62,24 +62,24 @@ function collectStyleScopedClassReferences(options, ctx, node) {
             && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
             && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
             && prop.arg.content === 'class') {
-            const content = '`${' + prop.exp.content + '}`';
-            const startOffset = prop.exp.loc.start.offset - 3;
+            const content = '(' + prop.exp.content + ')';
+            const startOffset = prop.exp.loc.start.offset - 1;
             const { ts } = options;
             const ast = ts.createSourceFile('', content, 99);
             const literals = [];
             ts.forEachChild(ast, node => {
                 if (!ts.isExpressionStatement(node)
-                    || !isTemplateExpression(node.expression)) {
+                    || !ts.isParenthesizedExpression(node.expression)) {
                     return;
                 }
-                const expression = node.expression.templateSpans[0].expression;
+                const { expression } = node.expression;
                 if (ts.isStringLiteralLike(expression)) {
                     literals.push(expression);
                 }
-                if (ts.isArrayLiteralExpression(expression)) {
+                else if (ts.isArrayLiteralExpression(expression)) {
                     walkArrayLiteral(expression);
                 }
-                if (ts.isObjectLiteralExpression(expression)) {
+                else if (ts.isObjectLiteralExpression(expression)) {
                     walkObjectLiteral(expression);
                 }
             });
@@ -160,8 +160,4 @@ function collectClasses(content, startOffset = 0) {
     }
     return classes;
 }
-// isTemplateExpression is missing in tsc
-function isTemplateExpression(node) {
-    return node.kind === 228;
-}
 //# sourceMappingURL=styleScopedClasses.js.map

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,15 +1,14 @@
 import type * as ts from 'typescript';
-import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from '../types';
-export type ParsedCommandLine = ts.ParsedCommandLine & {
+import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from './types';
+interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
+}
+export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
     vueOptions: VueCompilerOptions;
-};
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost & {
-    writeFile?(path: string, data: string): void;
-}, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
+}
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), host: ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
+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;
@@ -21,3 +20,4 @@ export declare class CompilerOptionsResolver {
 }
 export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
 export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
+export {};

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/file-html.js

@@ -4,7 +4,7 @@ const sfcBlockReg = /<(script|style)\b([\s\S]*?)>([\s\S]*?)<\/\1>/g;
 const langReg = /\blang\s*=\s*(['"]?)(\S*)\b\1/;
 const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2.1,
+        version: 2.2,
         getLanguageId(fileName) {
             if (vueCompilerOptions.petiteVueExtensions.some(ext => fileName.endsWith(ext))) {
                 return 'html';

package/lib/plugins/file-md.js

@@ -15,7 +15,7 @@ const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
 const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
 const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2.1,
+        version: 2.2,
         getLanguageId(fileName) {
             if (vueCompilerOptions.vitePressExtensions.some(ext => fileName.endsWith(ext))) {
                 return 'markdown';

package/lib/plugins/file-vue.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const parseSfc_1 = require("../utils/parseSfc");
 const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2.1,
+        version: 2.2,
         getLanguageId(fileName) {
             if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
                 return 'vue';

package/lib/plugins/vue-root-tags.js

@@ -4,7 +4,7 @@ const muggle_string_1 = require("muggle-string");
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes() {
             return [{
                     id: 'root_tags',

package/lib/plugins/vue-script-js.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = ({ modules }) => {
     return {
-        version: 2.1,
+        version: 2.2,
         compileSFCScript(lang, script) {
             if (lang === 'js' || lang === 'ts' || lang === 'jsx' || lang === 'tsx') {
                 const ts = modules.typescript;

package/lib/plugins/vue-sfc-customblocks.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes(_fileName, sfc) {
             return sfc.customBlocks.map((customBlock, i) => ({
                 id: 'custom_block_' + i,

package/lib/plugins/vue-sfc-scripts.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes(_fileName, sfc) {
             const names = [];
             if (sfc.script) {

package/lib/plugins/vue-sfc-styles.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes(_fileName, sfc) {
             const result = [];
             for (let i = 0; i < sfc.styles.length; i++) {
@@ -13,7 +13,7 @@ const plugin = () => {
                         id: 'style_' + i,
                         lang: style.lang,
                     });
-                    if (style.cssVars.length) {
+                    if (style.bindings.length) {
                         result.push({
                             id: 'style_' + i + '_inline_ts',
                             lang: 'ts',
@@ -29,11 +29,11 @@ const plugin = () => {
                 const style = sfc.styles[index];
                 if (embeddedFile.id.endsWith('_inline_ts')) {
                     embeddedFile.parentCodeId = 'style_' + index;
-                    for (const cssVar of style.cssVars) {
+                    for (const binding of style.bindings) {
                         embeddedFile.content.push('(', [
-                            cssVar.text,
+                            binding.text,
                             style.name,
-                            cssVar.offset,
+                            binding.offset,
                             shared_1.allCodeFeatures,
                         ], ');\n');
                     }

package/lib/plugins/vue-sfc-template.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes(_fileName, sfc) {
             if (sfc.template?.lang === 'html') {
                 return [{

package/lib/plugins/vue-template-html.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shouldAddSuffix = /(?<=<[^>/]+)$/;
 const plugin = ({ modules }) => {
     return {
-        version: 2.1,
+        version: 2.2,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
                 const compiler = modules['@vue/compiler-dom'];

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

@@ -10,7 +10,7 @@ const codeFeatures = {
 };
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes(_fileName, sfc) {
             if (!sfc.template?.ast) {
                 return [];

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

@@ -24,7 +24,7 @@ const formatBrackets = {
 const plugin = ctx => {
     const parseds = new WeakMap();
     return {
-        version: 2.1,
+        version: 2.2,
         getEmbeddedCodes(_fileName, sfc) {
             if (!sfc.template?.ast) {
                 return [];

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;