@vue/language-core 2.1.10 → 2.2.2

package/lib/codegen/script/src.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSrc = generateSrc;
-const common_1 = require("../common");
-const index_1 = require("./index");
+const codeFeatures_1 = require("../codeFeatures");
+const utils_1 = require("../utils");
 function* generateSrc(script, src) {
     if (src.endsWith('.d.ts')) {
-        src = src.substring(0, src.length - '.d.ts'.length);
+        src = src.slice(0, -'.d.ts'.length);
     }
     else if (src.endsWith('.ts')) {
-        src = src.substring(0, src.length - '.ts'.length);
+        src = src.slice(0, -'.ts'.length);
     }
     else if (src.endsWith('.tsx')) {
-        src = src.substring(0, src.length - '.tsx'.length) + '.jsx';
+        src = src.slice(0, -'.tsx'.length) + '.jsx';
     }
     if (!src.endsWith('.js') && !src.endsWith('.jsx')) {
         src = src + '.js';
@@ -22,7 +22,7 @@ function* generateSrc(script, src) {
         'script',
         script.srcOffset - 1,
         {
-            ...index_1.codeFeatures.all,
+            ...codeFeatures_1.codeFeatures.all,
             navigation: src === script.src
                 ? true
                 : {
@@ -45,7 +45,7 @@ function* generateSrc(script, src) {
                 },
         },
     ];
-    yield common_1.endOfLine;
-    yield `export { default } from '${src}'${common_1.endOfLine}`;
+    yield utils_1.endOfLine;
+    yield `export { default } from '${src}'${utils_1.endOfLine}`;
 }
 //# sourceMappingURL=src.js.map

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

@@ -1,4 +1,4 @@
 import type { Code } from '../../types';
 import type { ScriptCodegenContext } from './context';
-import { ScriptCodegenOptions } from './index';
+import type { ScriptCodegenOptions } from './index';
 export declare function generateStyleModulesType(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;

package/lib/codegen/script/styleModulesType.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleModulesType = generateStyleModulesType;
-const index_1 = require("./index");
+const codeFeatures_1 = require("../codeFeatures");
+const utils_1 = require("../utils");
 const template_1 = require("./template");
-const common_1 = require("../common");
 function* generateStyleModulesType(options, ctx) {
     const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
-    if (!styles.length && !options.scriptSetupRanges?.cssModules.length) {
+    if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
         return;
     }
-    yield `type __VLS_StyleModules = {${common_1.newLine}`;
+    yield `type __VLS_StyleModules = {${utils_1.newLine}`;
     for (const [style, i] of styles) {
         const { name, offset } = style.module;
         if (offset) {
@@ -17,7 +17,7 @@ function* generateStyleModulesType(options, ctx) {
                 name,
                 'main',
                 offset + 1,
-                index_1.codeFeatures.all
+                codeFeatures_1.codeFeatures.all
             ];
         }
         else {
@@ -27,8 +27,8 @@ function* generateStyleModulesType(options, ctx) {
         for (const className of style.classNames) {
             yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
         }
-        yield `>${common_1.endOfLine}`;
+        yield `>${utils_1.endOfLine}`;
     }
-    yield `}${common_1.endOfLine}`;
+    yield `}${utils_1.endOfLine}`;
 }
 //# sourceMappingURL=styleModulesType.js.map

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

@@ -1,8 +1,8 @@
 import type { Code } from '../../types';
 import { TemplateCodegenContext } from '../template/context';
 import type { ScriptCodegenContext } from './context';
-import { type ScriptCodegenOptions } from './index';
-export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
+import type { ScriptCodegenOptions } from './index';
 export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code, TemplateCodegenContext>;
+export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
 export declare function generateCssClassProperty(styleIndex: number, classNameWithDot: string, offset: number, propertyType: string, optional: boolean): Generator<Code>;
 export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;

package/lib/codegen/script/template.js

@@ -1,16 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTemplateDirectives = generateTemplateDirectives;
 exports.generateTemplate = generateTemplate;
+exports.generateTemplateDirectives = generateTemplateDirectives;
 exports.generateCssClassProperty = generateCssClassProperty;
 exports.getTemplateUsageVars = getTemplateUsageVars;
-const path = require("path-browserify");
 const shared_1 = require("../../utils/shared");
-const common_1 = require("../common");
+const codeFeatures_1 = require("../codeFeatures");
 const context_1 = require("../template/context");
 const interpolation_1 = require("../template/interpolation");
 const styleScopedClasses_1 = require("../template/styleScopedClasses");
-const index_1 = require("./index");
+const utils_1 = require("../utils");
+function* generateTemplate(options, ctx) {
+    ctx.generatedTemplate = true;
+    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
+        scriptSetupBindingNames: new Set(),
+        edited: options.edited,
+    });
+    yield* generateTemplateCtx(options);
+    yield* generateTemplateComponents(options);
+    yield* generateTemplateDirectives(options);
+    yield* generateTemplateBody(options, templateCodegenCtx);
+    return templateCodegenCtx;
+}
 function* generateTemplateCtx(options) {
     const exps = [];
     exps.push(`{} as InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>`);
@@ -23,101 +34,93 @@ function* generateTemplateCtx(options) {
     yield `const __VLS_ctx = `;
     if (exps.length === 1) {
         yield exps[0];
-        yield `${common_1.endOfLine}`;
+        yield `${utils_1.endOfLine}`;
     }
     else {
-        yield `{${common_1.newLine}`;
+        yield `{${utils_1.newLine}`;
         for (const exp of exps) {
             yield `...`;
             yield exp;
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
-        yield `}${common_1.endOfLine}`;
+        yield `}${utils_1.endOfLine}`;
     }
 }
 function* generateTemplateComponents(options) {
-    const exps = [];
+    const types = [];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
         const { componentsOption } = options.scriptRanges.exportDefault;
-        exps.push([
-            options.sfc.script.content.substring(componentsOption.start, componentsOption.end),
+        yield `const __VLS_componentsOption = `;
+        yield [
+            options.sfc.script.content.slice(componentsOption.start, componentsOption.end),
             'script',
             componentsOption.start,
-            index_1.codeFeatures.navigation,
-        ]);
-    }
-    let nameType;
-    if (options.sfc.script && options.scriptRanges?.exportDefault?.nameOption) {
-        const { nameOption } = options.scriptRanges.exportDefault;
-        nameType = options.sfc.script.content.substring(nameOption.start, nameOption.end);
-    }
-    else if (options.sfc.scriptSetup) {
-        const baseName = path.basename(options.fileName);
-        nameType = `'${options.scriptSetupRanges?.options.name ?? baseName.substring(0, baseName.lastIndexOf('.'))}'`;
-    }
-    if (nameType) {
-        exps.push(`{} as {
-			[K in ${nameType}]: typeof __VLS_self
-				& (new () => {
-					${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: typeof ${options.scriptSetupRanges?.slots?.name ?? '__VLS_slots'}
-				})
-		}`);
-    }
-    exps.push(`{} as NonNullable<typeof __VLS_self extends { components: infer C } ? C : {}>`);
-    exps.push(`__VLS_ctx`);
-    yield `const __VLS_localComponents = {${common_1.newLine}`;
-    for (const type of exps) {
-        yield `...`;
+            codeFeatures_1.codeFeatures.navigation,
+        ];
+        yield utils_1.endOfLine;
+        types.push(`typeof __VLS_componentsOption`);
+    }
+    types.push(`typeof __VLS_ctx`);
+    yield `type __VLS_LocalComponents =`;
+    for (const type of types) {
+        yield ` & `;
         yield type;
-        yield `,${common_1.newLine}`;
     }
-    yield `}${common_1.endOfLine}`;
-    yield `let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents${common_1.endOfLine}`;
+    yield utils_1.endOfLine;
+    yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
 function* generateTemplateDirectives(options) {
-    const exps = [];
+    const types = [];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
         const { directivesOption } = options.scriptRanges.exportDefault;
-        exps.push([
-            options.sfc.script.content.substring(directivesOption.start, directivesOption.end),
+        yield `const __VLS_directivesOption = `;
+        yield [
+            options.sfc.script.content.slice(directivesOption.start, directivesOption.end),
             'script',
             directivesOption.start,
-            index_1.codeFeatures.navigation,
-        ]);
-    }
-    exps.push(`{} as NonNullable<typeof __VLS_self extends { directives: infer D } ? D : {}>`);
-    exps.push(`__VLS_ctx`);
-    yield `const __VLS_localDirectives = {${common_1.newLine}`;
-    for (const type of exps) {
-        yield `...`;
+            codeFeatures_1.codeFeatures.navigation,
+        ];
+        yield utils_1.endOfLine;
+        types.push(`typeof __VLS_directivesOption`);
+    }
+    types.push(`typeof __VLS_ctx`);
+    yield `type __VLS_LocalDirectives =`;
+    for (const type of types) {
+        yield ` & `;
         yield type;
-        yield `,${common_1.newLine}`;
     }
-    yield `}${common_1.endOfLine}`;
-    yield `let __VLS_directives!: typeof __VLS_localDirectives & __VLS_GlobalDirectives${common_1.endOfLine}`;
-}
-function* generateTemplate(options, ctx) {
-    ctx.generatedTemplate = true;
-    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
-        scriptSetupBindingNames: new Set(),
-        edited: options.edited,
-    });
-    yield* generateTemplateCtx(options);
-    yield* generateTemplateComponents(options);
-    yield* generateTemplateDirectives(options);
-    yield* generateTemplateBody(options, templateCodegenCtx);
-    return templateCodegenCtx;
+    yield utils_1.endOfLine;
+    yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
 }
 function* generateTemplateBody(options, templateCodegenCtx) {
+    yield* generateStyleScopedClasses(options, templateCodegenCtx);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(templateCodegenCtx, true);
+    yield* generateCssVars(options, templateCodegenCtx);
+    if (options.templateCodegen) {
+        for (const code of options.templateCodegen.codes) {
+            yield code;
+        }
+    }
+    else {
+        yield `// no template${utils_1.newLine}`;
+        if (!options.scriptSetupRanges?.defineSlots) {
+            yield `type __VLS_Slots = {}${utils_1.endOfLine}`;
+        }
+        yield `type __VLS_InheritedAttrs = {}${utils_1.endOfLine}`;
+        yield `type __VLS_TemplateRefs = {}${utils_1.endOfLine}`;
+        yield `type __VLS_RootEl = any${utils_1.endOfLine}`;
+    }
+}
+function* generateStyleScopedClasses(options, ctx) {
     const firstClasses = new Set();
-    yield `let __VLS_styleScopedClasses!: {}`;
+    yield `type __VLS_StyleScopedClasses = {}`;
     for (let i = 0; i < options.sfc.styles.length; i++) {
         const style = options.sfc.styles[i];
         const option = options.vueCompilerOptions.experimentalResolveStyleCssClasses;
         if (option === 'always' || (option === 'scoped' && style.scoped)) {
             for (const className of style.classNames) {
                 if (firstClasses.has(className.text)) {
-                    templateCodegenCtx.scopedClasses.push({
+                    ctx.scopedClasses.push({
                         source: 'style_' + i,
                         className: className.text.slice(1),
                         offset: className.offset + 1
@@ -129,51 +132,29 @@ function* generateTemplateBody(options, templateCodegenCtx) {
             }
         }
     }
-    yield common_1.endOfLine;
-    yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(templateCodegenCtx, true);
-    yield* generateCssVars(options, templateCodegenCtx);
-    if (options.templateCodegen) {
-        for (const code of options.templateCodegen.codes) {
-            yield code;
-        }
-    }
-    else {
-        yield `// no template${common_1.newLine}`;
-        if (!options.scriptSetupRanges?.slots.define) {
-            yield `const __VLS_slots = {}${common_1.endOfLine}`;
-        }
-        yield `const __VLS_inheritedAttrs = {}${common_1.endOfLine}`;
-        yield `const $refs = {}${common_1.endOfLine}`;
-        yield `const $el = {} as any${common_1.endOfLine}`;
-    }
-    yield `return {${common_1.newLine}`;
-    yield `	attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${common_1.newLine}`;
-    yield `	slots: ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'},${common_1.newLine}`;
-    yield `	refs: $refs,${common_1.newLine}`;
-    yield `	rootEl: $el,${common_1.newLine}`;
-    yield `}${common_1.endOfLine}`;
+    yield utils_1.endOfLine;
 }
 function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propertyType, optional) {
-    yield `${common_1.newLine} & { `;
+    yield `${utils_1.newLine} & { `;
     yield [
         '',
         'style_' + styleIndex,
         offset,
-        index_1.codeFeatures.navigation,
+        codeFeatures_1.codeFeatures.navigation,
     ];
     yield `'`;
     yield [
-        classNameWithDot.substring(1),
+        classNameWithDot.slice(1),
         'style_' + styleIndex,
         offset + 1,
-        index_1.codeFeatures.navigation,
+        codeFeatures_1.codeFeatures.navigation,
     ];
     yield `'`;
     yield [
         '',
         'style_' + styleIndex,
         offset + classNameWithDot.length,
-        index_1.codeFeatures.navigationWithoutRename,
+        codeFeatures_1.codeFeatures.navigationWithoutRename,
     ];
     yield `${optional ? '?' : ''}: ${propertyType}`;
     yield ` }`;
@@ -182,28 +163,14 @@ function* generateCssVars(options, ctx) {
     if (!options.sfc.styles.length) {
         return;
     }
-    yield `// CSS variable injection ${common_1.newLine}`;
+    yield `// CSS variable injection ${utils_1.newLine}`;
     for (const style of options.sfc.styles) {
         for (const cssBind of style.cssVars) {
-            for (const [segment, offset, onlyError] of (0, interpolation_1.forEachInterpolationSegment)(options.ts, undefined, undefined, ctx, cssBind.text, cssBind.offset, options.ts.createSourceFile('/a.txt', cssBind.text, 99))) {
-                if (offset === undefined) {
-                    yield segment;
-                }
-                else {
-                    yield [
-                        segment,
-                        style.name,
-                        cssBind.offset + offset,
-                        onlyError
-                            ? index_1.codeFeatures.navigation
-                            : index_1.codeFeatures.all,
-                    ];
-                }
-            }
-            yield common_1.endOfLine;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style.name, codeFeatures_1.codeFeatures.all, cssBind.text, cssBind.offset);
+            yield utils_1.endOfLine;
         }
     }
-    yield `// CSS variable injection end ${common_1.newLine}`;
+    yield `// CSS variable injection end ${utils_1.newLine}`;
 }
 function getTemplateUsageVars(options, ctx) {
     const usageVars = new Set();
@@ -216,7 +183,7 @@ function getTemplateUsageVars(options, ctx) {
             }
         }
         for (const component of components) {
-            if (component.indexOf('.') >= 0) {
+            if (component.includes('.')) {
                 usageVars.add(component.split('.')[0]);
             }
         }

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

@@ -1,37 +1,46 @@
 import type * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, VueCodeInformation } from '../../types';
-import type { TemplateCodegenOptions } from './index';
 import { InlayHintInfo } from '../inlayHints';
+import type { TemplateCodegenOptions } from './index';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
 export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
-    slots: {
-        name: string;
-        loc?: number;
-        tagRange: [number, number];
-        varName: string;
-        nodeLoc: any;
-    }[];
-    dynamicSlots: {
-        expVar: string;
-        varName: string;
-    }[];
     codeFeatures: {
         all: VueCodeInformation;
+        none: VueCodeInformation;
         verification: VueCodeInformation;
         completion: VueCodeInformation;
         additionalCompletion: VueCodeInformation;
+        withoutCompletion: VueCodeInformation;
         navigation: VueCodeInformation;
         navigationWithoutRename: VueCodeInformation;
         navigationAndCompletion: VueCodeInformation;
         navigationAndAdditionalCompletion: VueCodeInformation;
+        navigationAndVerification: VueCodeInformation;
+        withoutNavigation: VueCodeInformation;
         withoutHighlight: VueCodeInformation;
+        withoutHighlightAndNavigation: VueCodeInformation;
         withoutHighlightAndCompletion: VueCodeInformation;
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
     };
+    resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
+    slots: {
+        name: string;
+        offset?: number;
+        tagRange: [number, number];
+        nodeLoc: any;
+        propsVar: string;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        propsVar: string;
+    }[];
+    specialVars: Set<string>;
     accessExternalVariables: Map<string, Set<number>>;
-    hasSlotElements: Set<CompilerDOM.ElementNode>;
+    lastGenericComment: {
+        content: string;
+        offset: number;
+    } | undefined;
     blockConditions: string[];
-    usedComponentCtxVars: Set<string>;
     scopedClasses: {
         source: string;
         className: string;
@@ -40,8 +49,13 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     emptyClassOffsets: number[];
     inlayHints: InlayHintInfo[];
     hasSlot: boolean;
-    inheritedAttrVars: Set<unknown>;
+    bindingAttrLocs: CompilerDOM.SourceLocation[];
+    inheritedAttrVars: Set<string>;
     templateRefs: Map<string, [varName: string, offset: number]>;
+    currentComponent: {
+        ctxVar: string;
+        used: boolean;
+    } | undefined;
     singleRootElType: string | undefined;
     singleRootNode: CompilerDOM.ElementNode | undefined;
     accessExternalVariable(name: string, offset?: number): void;