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

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/codegen/tenp.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/codegen/tenp.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tenp.js.map

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/parsers/utils.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+import type { TextRange } from '../types';
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
+    range: TextRange;
+    moduleName?: string;
+    isDefaultImport?: boolean;
+    isNamespace?: boolean;
+}[];
+export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
+    start: number;
+    end: number;
+} | undefined;

package/lib/parsers/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBindingRanges = parseBindingRanges;
+exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
+const collectBindings_1 = require("../utils/collectBindings");
+const shared_1 = require("../utils/shared");
+function parseBindingRanges(ts, ast) {
+    const bindings = [];
+    ts.forEachChild(ast, node => {
+        if (ts.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
+                bindings.push(...ranges.map(range => ({ range })));
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push({
+                range: _getStartEnd(node.name),
+            });
+        }
+        if (ts.isImportDeclaration(node)) {
+            const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                const { name, namedBindings } = node.importClause;
+                if (name) {
+                    bindings.push({
+                        range: _getStartEnd(name),
+                        moduleName,
+                        isDefaultImport: true,
+                    });
+                }
+                if (namedBindings) {
+                    if (ts.isNamedImports(namedBindings)) {
+                        for (const element of namedBindings.elements) {
+                            if (element.isTypeOnly) {
+                                continue;
+                            }
+                            bindings.push({
+                                range: _getStartEnd(element.name),
+                                moduleName,
+                                isDefaultImport: element.propertyName?.text === 'default',
+                            });
+                        }
+                    }
+                    else {
+                        bindings.push({
+                            range: _getStartEnd(namedBindings.name),
+                            moduleName,
+                            isNamespace: true,
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return (0, shared_1.getStartEnd)(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return (0, shared_1.getNodeText)(ts, node, ast);
+    }
+}
+function getClosestMultiLineCommentRange(ts, node, parents, ast) {
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(node)) {
+            break;
+        }
+        node = parents[i];
+    }
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
+        return {
+            start: comment.pos,
+            end: comment.end,
+        };
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/plugins/file-css.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-css.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = ({ vueCompilerOptions }) => {
+    return {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                return 'vue';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'vue';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'vue') {
+                return;
+            }
+            return (0, parseSfc_1.parse)(content);
+        },
+        updateSFC(sfc, change) {
+            const blocks = [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ].filter(block => !!block);
+            const hitBlock = blocks.find(block => change.start >= block.loc.start.offset && change.end <= block.loc.end.offset);
+            if (!hitBlock) {
+                return;
+            }
+            const oldContent = hitBlock.content;
+            const newContent = hitBlock.content = hitBlock.content.slice(0, change.start - hitBlock.loc.start.offset)
+                + change.newText
+                + hitBlock.content.slice(change.end - hitBlock.loc.start.offset);
+            // #3449
+            const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = endTagRegex.test(oldContent) !== endTagRegex.test(newContent);
+            if (insertedEndTag) {
+                return;
+            }
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            for (const block of blocks) {
+                if (block.loc.start.offset > change.end) {
+                    block.loc.start.offset += lengthDiff;
+                }
+                if (block.loc.end.offset >= change.end) {
+                    block.loc.end.offset += lengthDiff;
+                }
+            }
+            return sfc;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-css.js.map

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/parseCssClassNames.d.ts

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

package/lib/utils/parseCssClassNames.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssClassNames = parseCssClassNames;
+const parseCssVars_1 = require("./parseCssVars");
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const fragmentReg = /(?<={)[^{]*(?=(?<!\\);)/g;
+function* parseCssClassNames(css) {
+    css = (0, parseCssVars_1.fillBlank)(css, parseCssVars_1.commentReg, fragmentReg);
+    const matches = css.matchAll(cssClassNameReg);
+    for (const match of matches) {
+        const matchText = match[1];
+        if (matchText) {
+            yield { offset: match.index, text: matchText };
+        }
+    }
+}
+//# sourceMappingURL=parseCssClassNames.js.map

package/lib/utils/parseCssImports.d.ts

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

package/lib/utils/parseCssImports.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssImports = parseCssImports;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith("'") || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+//# sourceMappingURL=parseCssImports.js.map

package/lib/utils/parseCssVars.d.ts

@@ -0,0 +1,6 @@
+export declare const commentReg: RegExp;
+export declare function parseCssVars(css: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;
+export declare function fillBlank(css: string, ...regs: RegExp[]): string;

package/lib/utils/parseCssVars.js

@@ -0,0 +1,26 @@
+"use strict";
+// https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/cssVars.ts#L47-L61
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commentReg = void 0;
+exports.parseCssVars = parseCssVars;
+exports.fillBlank = fillBlank;
+const vBindCssVarReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([a-z_]\w*))\s*\)/gi;
+exports.commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+function* parseCssVars(css) {
+    css = fillBlank(css, exports.commentReg);
+    const matchs = css.matchAll(vBindCssVarReg);
+    for (const match of matchs) {
+        const matchText = match.slice(1).find(t => t);
+        if (matchText) {
+            const offset = match.index + css.slice(match.index).indexOf(matchText);
+            yield { offset, text: matchText };
+        }
+    }
+}
+function fillBlank(css, ...regs) {
+    for (const reg of regs) {
+        css = css.replace(reg, match => ' '.repeat(match.length));
+    }
+    return css;
+}
+//# sourceMappingURL=parseCssVars.js.map

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/ts.d.ts

@@ -0,0 +1,24 @@
+import type * as ts from 'typescript';
+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'), 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;
+    plugins: VueLanguagePlugin[];
+    constructor(fileExists?: ((path: string) => boolean) | undefined);
+    addConfig(options: RawVueCompilerOptions, rootDir: string): void;
+    build(defaults?: VueCompilerOptions): VueCompilerOptions;
+    private findNodeModulesRoot;
+}
+export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
+export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
+export {};

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/package.json

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