@vue/language-core 2.0.13 → 2.0.15

package/lib/codegen/script/template.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateUsageVars = exports.generateTemplate = void 0;
+const shared_1 = require("../../utils/shared");
+const common_1 = require("../common");
+const context_1 = require("../template/context");
+const interpolation_1 = require("../template/interpolation");
+const index_1 = require("./index");
+const internalComponent_1 = require("./internalComponent");
+const common_2 = require("../common");
+function* generateTemplate(options, ctx) {
+    ctx.generatedTemplate = true;
+    if (!options.vueCompilerOptions.skipTemplateCodegen) {
+        yield* generateExportOptions(options);
+        yield* generateConstNameOption(options);
+        yield `function __VLS_template() {${common_1.newLine}`;
+        const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)();
+        yield* generateTemplateContext(options, ctx, templateCodegenCtx);
+        yield `}${common_1.newLine}`;
+        yield* (0, internalComponent_1.generateInternalComponent)(options, ctx, templateCodegenCtx);
+    }
+    else {
+        yield `function __VLS_template() {${common_1.newLine}`;
+        const templateUsageVars = [...getTemplateUsageVars(options, ctx)];
+        yield `// @ts-ignore${common_1.newLine}`;
+        yield `[${templateUsageVars.join(', ')}]${common_1.newLine}`;
+        yield `return {}${common_1.endOfLine}`;
+        yield `}${common_1.newLine}`;
+    }
+}
+exports.generateTemplate = generateTemplate;
+function* generateExportOptions(options) {
+    yield common_1.newLine;
+    yield `const __VLS_componentsOption = `;
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
+        const componentsOption = options.scriptRanges.exportDefault.componentsOption;
+        yield [
+            options.sfc.script.content.substring(componentsOption.start, componentsOption.end),
+            'script',
+            componentsOption.start,
+            index_1.codeFeatures.navigation,
+        ];
+    }
+    else {
+        yield `{}`;
+    }
+    yield common_1.endOfLine;
+}
+function* generateConstNameOption(options) {
+    yield common_1.newLine;
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.nameOption) {
+        const nameOption = options.scriptRanges.exportDefault.nameOption;
+        yield `const __VLS_name = `;
+        yield `${options.sfc.script.content.substring(nameOption.start, nameOption.end)} as const`;
+        yield common_1.endOfLine;
+    }
+    else if (options.sfc.scriptSetup) {
+        yield `let __VLS_name!: '${options.fileBaseName.substring(0, options.fileBaseName.lastIndexOf('.'))}'${common_1.endOfLine}`;
+    }
+    else {
+        yield `const __VLS_name = undefined${common_1.endOfLine}`;
+    }
+}
+function* generateTemplateContext(options, ctx, templateCodegenCtx) {
+    const useGlobalThisTypeInCtx = options.fileBaseName.endsWith('.html');
+    yield `let __VLS_ctx!: ${useGlobalThisTypeInCtx ? 'typeof globalThis &' : ''}`;
+    yield `InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>> & {${common_1.newLine}`;
+    /* CSS Module */
+    for (let i = 0; i < options.sfc.styles.length; i++) {
+        const style = options.sfc.styles[i];
+        if (style.module) {
+            yield `${style.module}: Record<string, string> & ${ctx.helperTypes.Prettify.name}<{}`;
+            for (const className of style.classNames) {
+                yield* generateCssClassProperty(i, className.text, className.offset, 'string', false, true);
+            }
+            yield `>${common_1.endOfLine}`;
+        }
+    }
+    yield `}${common_1.endOfLine}`;
+    /* Components */
+    yield `/* Components */${common_1.newLine}`;
+    yield `let __VLS_otherComponents!: NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}> & typeof __VLS_componentsOption${common_1.endOfLine}`;
+    yield `let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: typeof ${options.scriptSetupRanges?.slots?.name ?? '__VLS_slots'} })>${common_1.endOfLine}`;
+    yield `let __VLS_localComponents!: typeof __VLS_otherComponents & Omit<typeof __VLS_own, keyof typeof __VLS_otherComponents>${common_1.endOfLine}`;
+    yield `let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents & typeof __VLS_ctx${common_1.endOfLine}`; // for html completion, TS references...
+    /* Style Scoped */
+    yield `/* Style Scoped */${common_1.newLine}`;
+    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) {
+                yield* generateCssClassProperty(i, className.text, className.offset, 'boolean', true, !style.module);
+            }
+        }
+    }
+    yield common_1.endOfLine;
+    yield `let __VLS_styleScopedClasses!: __VLS_StyleScopedClasses | keyof __VLS_StyleScopedClasses | (keyof __VLS_StyleScopedClasses)[]${common_1.endOfLine}`;
+    yield* generateCssVars(options, templateCodegenCtx);
+    if (options.templateCodegen) {
+        for (const code of options.templateCodegen.tsCodes) {
+            yield code;
+        }
+    }
+    else {
+        yield `// no template${common_1.newLine}`;
+        if (!options.scriptSetupRanges?.slots.define) {
+            yield `const __VLS_slots = {}${common_1.endOfLine}`;
+        }
+    }
+    yield `return ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'}${common_1.endOfLine}`;
+}
+function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propertyType, optional, referencesCodeLens) {
+    yield `${common_1.newLine} & { `;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset,
+        referencesCodeLens
+            ? index_1.codeFeatures.navigation
+            : index_1.codeFeatures.referencesCodeLens,
+    ];
+    yield `'`;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset,
+        index_1.codeFeatures.cssClassNavigation,
+    ];
+    yield [
+        classNameWithDot.substring(1),
+        'style_' + styleIndex,
+        offset + 1,
+        common_2.combineLastMapping,
+    ];
+    yield `'`;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset + classNameWithDot.length,
+        index_1.codeFeatures.none,
+    ];
+    yield `${optional ? '?' : ''}: ${propertyType}`;
+    yield ` }`;
+}
+function* generateCssVars(options, ctx) {
+    if (!options.sfc.styles.length) {
+        return;
+    }
+    yield `// CSS variable injection ${common_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, options.vueCompilerOptions, 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 `// CSS variable injection end ${common_1.newLine}`;
+}
+function getTemplateUsageVars(options, ctx) {
+    const usageVars = new Set();
+    const components = new Set(options.sfc.template?.ast?.components);
+    if (options.templateCodegen) {
+        // fix import components unused report
+        for (const varName of ctx.bindingNames) {
+            if (components.has(varName) || components.has((0, shared_1.hyphenateTag)(varName))) {
+                usageVars.add(varName);
+            }
+        }
+        for (const component of components) {
+            if (component.indexOf('.') >= 0) {
+                usageVars.add(component.split('.')[0]);
+            }
+        }
+        for (const [varName] of options.templateCodegen.ctx.accessGlobalVariables) {
+            usageVars.add(varName);
+        }
+    }
+    return usageVars;
+}
+exports.getTemplateUsageVars = getTemplateUsageVars;
+//# sourceMappingURL=template.js.map

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

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateCamelized(code: string, offset: number, info: VueCodeInformation): Generator<Code>;

package/lib/codegen/template/camelized.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCamelized = void 0;
+const shared_1 = require("@vue/shared");
+const common_1 = require("../common");
+function* generateCamelized(code, offset, info) {
+    const parts = code.split('-');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part !== '') {
+            if (i === 0) {
+                yield [
+                    part,
+                    'template',
+                    offset,
+                    info,
+                ];
+            }
+            else {
+                yield [
+                    (0, shared_1.capitalize)(part),
+                    'template',
+                    offset,
+                    common_1.combineLastMapping,
+                ];
+            }
+        }
+        offset += part.length + 1;
+    }
+}
+exports.generateCamelized = generateCamelized;
+//# sourceMappingURL=camelized.js.map

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

@@ -0,0 +1,44 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { Code, VueCodeInformation } from '../../types';
+export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
+export declare function createTemplateCodegenContext(): {
+    slots: {
+        name: string;
+        loc?: number | undefined;
+        tagRange: [number, number];
+        varName: string;
+        nodeLoc: any;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        varName: string;
+    }[];
+    codeFeatures: {
+        all: VueCodeInformation;
+        verification: VueCodeInformation;
+        completion: VueCodeInformation;
+        additionalCompletion: VueCodeInformation;
+        navigation: VueCodeInformation;
+        navigationAndCompletion: VueCodeInformation;
+        withoutHighlight: VueCodeInformation;
+        withoutHighlightAndCompletion: VueCodeInformation;
+        withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
+    };
+    accessGlobalVariables: Map<string, Set<number>>;
+    hasSlotElements: Set<CompilerDOM.ElementNode>;
+    blockConditions: string[];
+    usedComponentCtxVars: Set<string>;
+    scopedClasses: {
+        className: string;
+        offset: number;
+    }[];
+    accessGlobalVariable(name: string, offset?: number): void;
+    hasLocalVariable: (name: string) => boolean;
+    addLocalVariable: (name: string) => void;
+    removeLocalVariable: (name: string) => void;
+    getInternalVariable: () => string;
+    ignoreError: () => Generator<Code>;
+    expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
+    resetDirectiveComments: (endStr: string) => Generator<Code>;
+    generateAutoImportCompletion: () => Generator<Code>;
+};

package/lib/codegen/template/context.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplateCodegenContext = void 0;
+const common_1 = require("../common");
+const _codeFeatures = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    verification: {
+        verification: true,
+    },
+    completion: {
+        completion: true,
+    },
+    additionalCompletion: {
+        completion: { isAdditional: true },
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationAndCompletion: {
+        navigation: true,
+    },
+    withoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
+    withoutHighlightAndCompletion: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+    },
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+    },
+};
+function createTemplateCodegenContext() {
+    let ignoredError = false;
+    let expectErrorToken;
+    let variableId = 0;
+    const codeFeatures = new Proxy(_codeFeatures, {
+        get(target, key) {
+            const data = target[key];
+            if (data.verification) {
+                if (ignoredError) {
+                    return {
+                        ...data,
+                        verification: false,
+                    };
+                }
+                if (expectErrorToken) {
+                    const token = expectErrorToken;
+                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
+                        return {
+                            ...data,
+                            verification: {
+                                shouldReport: () => {
+                                    token.errors++;
+                                    return false;
+                                },
+                            },
+                        };
+                    }
+                }
+            }
+            return data;
+        },
+    });
+    const localVars = new Map();
+    const accessGlobalVariables = new Map();
+    const slots = [];
+    const dynamicSlots = [];
+    const hasSlotElements = new Set();
+    ;
+    const blockConditions = [];
+    const usedComponentCtxVars = new Set();
+    const scopedClasses = [];
+    return {
+        slots,
+        dynamicSlots,
+        codeFeatures,
+        accessGlobalVariables,
+        hasSlotElements,
+        blockConditions,
+        usedComponentCtxVars,
+        scopedClasses,
+        accessGlobalVariable(name, offset) {
+            let arr = accessGlobalVariables.get(name);
+            if (!arr) {
+                accessGlobalVariables.set(name, arr = new Set());
+            }
+            if (offset !== undefined) {
+                arr.add(offset);
+            }
+        },
+        hasLocalVariable: (name) => {
+            return !!localVars.get(name);
+        },
+        addLocalVariable: (name) => {
+            localVars.set(name, (localVars.get(name) ?? 0) + 1);
+        },
+        removeLocalVariable: (name) => {
+            localVars.set(name, localVars.get(name) - 1);
+        },
+        getInternalVariable: () => {
+            return `__VLS_${variableId++}`;
+        },
+        ignoreError: function* () {
+            if (!ignoredError) {
+                ignoredError = true;
+                yield `// @vue-ignore start${common_1.newLine}`;
+            }
+        },
+        expectError: function* (prevNode) {
+            if (!expectErrorToken) {
+                expectErrorToken = {
+                    errors: 0,
+                    node: prevNode,
+                };
+                yield `// @vue-expect-error start${common_1.newLine}`;
+            }
+        },
+        resetDirectiveComments: function* (endStr) {
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                yield* (0, common_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
+                    verification: {
+                        shouldReport: () => token.errors === 0,
+                    },
+                }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
+                yield `${common_1.newLine}${common_1.endOfLine}`;
+                expectErrorToken = undefined;
+                yield `// @vue-expect-error ${endStr}${common_1.newLine}`;
+            }
+            if (ignoredError) {
+                ignoredError = false;
+                yield `// @vue-ignore ${endStr}${common_1.newLine}`;
+            }
+        },
+        generateAutoImportCompletion: function* () {
+            const all = [...accessGlobalVariables.entries()];
+            if (!all.some(([_, offsets]) => offsets.size)) {
+                return;
+            }
+            yield `// @ts-ignore${common_1.newLine}`; // #2304
+            yield `[`;
+            for (const [varName, offsets] of all) {
+                for (const offset of offsets) {
+                    yield [
+                        varName,
+                        'template',
+                        offset,
+                        codeFeatures.additionalCompletion,
+                    ];
+                    yield `,`;
+                }
+                offsets.clear();
+            }
+            yield `]${common_1.endOfLine}`;
+        }
+    };
+}
+exports.createTemplateCodegenContext = createTemplateCodegenContext;
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,8 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function getCanonicalComponentName(tagText: string): string;
+export declare function getPossibleOriginalComponentNames(tagText: string, deduplicate: boolean): string[];