@vue/language-core 2.0.13 → 2.0.14

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

@@ -0,0 +1,5 @@
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import type { ScriptCodegenOptions } from './index';
+export declare function generateInternalComponent(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/script/internalComponent.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInternalComponent = void 0;
+const common_1 = require("../common");
+const component_1 = require("./component");
+const template_1 = require("./template");
+function* generateInternalComponent(options, ctx, templateCodegenCtx) {
+    if (options.sfc.scriptSetup && options.scriptSetupRanges) {
+        yield `const __VLS_internalComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+        yield `setup() {${common_1.newLine}`;
+        yield `return {${common_1.newLine}`;
+        if (ctx.bypassDefineComponent) {
+            yield* (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges);
+        }
+        // bindings
+        const templateUsageVars = (0, template_1.getTemplateUsageVars)(options, ctx);
+        for (const [content, bindings] of [
+            [options.sfc.scriptSetup.content, options.scriptSetupRanges.bindings],
+            options.sfc.script && options.scriptRanges
+                ? [options.sfc.script.content, options.scriptRanges.bindings]
+                : ['', []],
+        ]) {
+            for (const expose of bindings) {
+                const varName = content.substring(expose.start, expose.end);
+                if (!templateUsageVars.has(varName) && !templateCodegenCtx.accessGlobalVariables.has(varName)) {
+                    continue;
+                }
+                const templateOffset = options.getGeneratedLength();
+                yield `${varName}: ${varName} as typeof `;
+                const scriptOffset = options.getGeneratedLength();
+                yield `${varName},${common_1.newLine}`;
+                options.linkedCodeMappings.push({
+                    sourceOffsets: [scriptOffset],
+                    generatedOffsets: [templateOffset],
+                    lengths: [varName.length],
+                    data: undefined,
+                });
+            }
+        }
+        yield `}${common_1.endOfLine}`; // return {
+        yield `},${common_1.newLine}`; // setup() {
+        if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
+            yield* (0, component_1.generateScriptSetupOptions)(ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+        }
+        if (options.sfc.script && options.scriptRanges) {
+            yield* (0, component_1.generateScriptOptions)(options.sfc.script, options.scriptRanges);
+        }
+        yield `})${common_1.endOfLine}`; // defineComponent {
+    }
+    else if (options.sfc.script) {
+        yield `const __VLS_internalComponent = (await import('./${options.fileBaseName}')).default${common_1.endOfLine}`;
+    }
+    else {
+        yield `const __VLS_internalComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({})${common_1.endOfLine}`;
+    }
+}
+exports.generateInternalComponent = generateInternalComponent;
+//# sourceMappingURL=internalComponent.js.map

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

@@ -0,0 +1,6 @@
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateScriptSetupImports(scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Code;
+export declare function generateScriptSetup(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

package/lib/codegen/script/scriptSetup.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScriptSetup = exports.generateScriptSetupImports = void 0;
+const common_1 = require("../common");
+const component_1 = require("./component");
+const index_1 = require("./index");
+const template_1 = require("./template");
+function generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
+    return [
+        scriptSetup.content.substring(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)) + common_1.newLine,
+        'scriptSetup',
+        0,
+        index_1.codeFeatures.all,
+    ];
+}
+exports.generateScriptSetupImports = generateScriptSetupImports;
+function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
+    const definePropMirrors = new Map();
+    if (scriptSetup.generic) {
+        if (!options.scriptRanges?.exportDefault) {
+            yield `export default `;
+        }
+        yield `(<`;
+        yield [
+            scriptSetup.generic,
+            scriptSetup.name,
+            scriptSetup.genericOffset,
+            index_1.codeFeatures.all,
+        ];
+        if (!scriptSetup.generic.endsWith(`,`)) {
+            yield `,`;
+        }
+        yield `>(${common_1.newLine}`
+            + `	__VLS_props: Awaited<typeof __VLS_setup>['props'],${common_1.newLine}`
+            + `	__VLS_ctx?: ${ctx.helperTypes.Prettify.name}<Pick<Awaited<typeof __VLS_setup>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
+            + `	__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],${common_1.newLine}`
+            + `	__VLS_setup = (async () => {${common_1.newLine}`;
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, undefined, definePropMirrors);
+        yield `		return {} as {${common_1.newLine}`
+            + `			props: ${ctx.helperTypes.Prettify.name}<typeof __VLS_functionalComponentProps & typeof __VLS_componentProps> & typeof __VLS_publicProps,${common_1.newLine}`
+            + `			expose(exposed: import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.expose.define ? 'typeof __VLS_exposed' : '{}'}>): void,${common_1.newLine}`
+            + `			attrs: any,${common_1.newLine}`
+            + `			slots: ReturnType<typeof __VLS_template>,${common_1.newLine}`
+            + `			emit: typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'} & typeof __VLS_modelEmitsType,${common_1.newLine}`
+            + `		}${common_1.endOfLine}`;
+        yield `	})(),${common_1.newLine}`; // __VLS_setup = (async () => {
+        yield `) => ({} as import('${options.vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))`;
+    }
+    else if (!options.sfc.script) {
+        // no script block, generate script setup code at root
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'export default', definePropMirrors);
+    }
+    else {
+        if (!options.scriptRanges?.exportDefault) {
+            yield `export default `;
+        }
+        yield `await (async () => {${common_1.newLine}`;
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'return', definePropMirrors);
+        yield `})()`;
+    }
+    if (ctx.scriptSetupGeneratedOffset !== undefined) {
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            if (!defineProp.name) {
+                continue;
+            }
+            const propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+            const propMirror = definePropMirrors.get(propName);
+            if (propMirror !== undefined) {
+                options.linkedCodeMappings.push({
+                    sourceOffsets: [defineProp.name.start + ctx.scriptSetupGeneratedOffset],
+                    generatedOffsets: [propMirror],
+                    lengths: [defineProp.name.end - defineProp.name.start],
+                    data: undefined,
+                });
+            }
+        }
+    }
+}
+exports.generateScriptSetup = generateScriptSetup;
+function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, syntax, definePropMirrors) {
+    const definePropProposalA = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
+    const definePropProposalB = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
+    if (options.vueCompilerOptions.target >= 3.3) {
+        yield `const { `;
+        for (const macro of Object.keys(options.vueCompilerOptions.macros)) {
+            if (!ctx.bindingNames.has(macro)) {
+                yield macro + `, `;
+            }
+        }
+        yield `} = await import('${options.vueCompilerOptions.lib}')${common_1.endOfLine}`;
+    }
+    if (definePropProposalA) {
+        yield `declare function defineProp<T>(name: string, options: { required: true } & Record<string, unknown>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+        yield `declare function defineProp<T>(name: string, options: { default: any } & Record<string, unknown>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+        yield `declare function defineProp<T>(name?: string, options?: any): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${common_1.endOfLine}`;
+    }
+    if (definePropProposalB) {
+        yield `declare function defineProp<T>(value: T | (() => T), required?: boolean, rest?: any): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+        yield `declare function defineProp<T>(value: T | (() => T) | undefined, required: true, rest?: any): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+        yield `declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?: any): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${common_1.endOfLine}`;
+    }
+    ctx.scriptSetupGeneratedOffset = options.getGeneratedLength() - scriptSetupRanges.importSectionEndOffset;
+    let setupCodeModifies = [];
+    if (scriptSetupRanges.props.define && !scriptSetupRanges.props.name) {
+        const range = scriptSetupRanges.props.withDefaults ?? scriptSetupRanges.props.define;
+        const statement = scriptSetupRanges.props.define.statement;
+        if (statement.start === range.start && statement.end === range.end) {
+            setupCodeModifies.push([[`const __VLS_props = `], range.start, range.start]);
+        }
+        else {
+            setupCodeModifies.push([[
+                    `const __VLS_props = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, range.start, range.end, index_1.codeFeatures.all),
+                    `${common_1.endOfLine}`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, range.start, index_1.codeFeatures.all),
+                    `__VLS_props`,
+                ], statement.start, range.end]);
+        }
+    }
+    if (scriptSetupRanges.slots.define && !scriptSetupRanges.slots.name) {
+        setupCodeModifies.push([[`const __VLS_slots = `], scriptSetupRanges.slots.define.start, scriptSetupRanges.slots.define.start]);
+    }
+    if (scriptSetupRanges.emits.define && !scriptSetupRanges.emits.name) {
+        setupCodeModifies.push([[`const __VLS_emit = `], scriptSetupRanges.emits.define.start, scriptSetupRanges.emits.define.start]);
+    }
+    if (scriptSetupRanges.expose.define) {
+        if (scriptSetupRanges.expose.define?.typeArg) {
+            setupCodeModifies.push([
+                [
+                    `let __VLS_exposed!: `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.expose.define.typeArg.start, scriptSetupRanges.expose.define.typeArg.end, index_1.codeFeatures.navigation),
+                    `${common_1.endOfLine}`,
+                ],
+                scriptSetupRanges.expose.define.start,
+                scriptSetupRanges.expose.define.start,
+            ]);
+        }
+        else if (scriptSetupRanges.expose.define?.arg) {
+            setupCodeModifies.push([
+                [
+                    `const __VLS_exposed = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.expose.define.arg.start, scriptSetupRanges.expose.define.arg.end, index_1.codeFeatures.navigation),
+                    `${common_1.endOfLine}`,
+                ],
+                scriptSetupRanges.expose.define.start,
+                scriptSetupRanges.expose.define.start,
+            ]);
+        }
+        else {
+            setupCodeModifies.push([
+                [`const __VLS_exposed = {}${common_1.endOfLine}`],
+                scriptSetupRanges.expose.define.start,
+                scriptSetupRanges.expose.define.start,
+            ]);
+        }
+    }
+    setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
+    if (setupCodeModifies.length) {
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.importSectionEndOffset, setupCodeModifies[0][1], index_1.codeFeatures.all);
+        while (setupCodeModifies.length) {
+            const [codes, _start, end] = setupCodeModifies.shift();
+            for (const code of codes) {
+                yield code;
+            }
+            if (setupCodeModifies.length) {
+                const nextStart = setupCodeModifies[0][1];
+                yield (0, common_1.generateSfcBlockSection)(scriptSetup, end, nextStart, index_1.codeFeatures.all);
+            }
+            else {
+                yield (0, common_1.generateSfcBlockSection)(scriptSetup, end, scriptSetup.content.length, index_1.codeFeatures.all);
+            }
+        }
+    }
+    else {
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.importSectionEndOffset, scriptSetup.content.length, index_1.codeFeatures.all);
+    }
+    if (scriptSetupRanges.props.define?.typeArg && scriptSetupRanges.props.withDefaults?.arg) {
+        // fix https://github.com/vuejs/language-tools/issues/1187
+        yield `const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`;
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.withDefaults.arg.start, scriptSetupRanges.props.withDefaults.arg.end, index_1.codeFeatures.navigation);
+        yield `)${common_1.endOfLine}`;
+    }
+    yield* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors);
+    yield* generateModelEmits(options, scriptSetup, scriptSetupRanges);
+    yield* (0, template_1.generateTemplate)(options, ctx);
+    if (syntax) {
+        if (!options.vueCompilerOptions.skipTemplateCodegen && (options.templateCodegen?.hasSlot || scriptSetupRanges?.slots.define)) {
+            yield `const __VLS_component = `;
+            yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
+            yield common_1.endOfLine;
+            yield `${syntax} `;
+            yield `{} as ${ctx.helperTypes.WithTemplateSlots.name}<typeof __VLS_component, ReturnType<typeof __VLS_template>>${common_1.endOfLine}`;
+        }
+        else {
+            yield `${syntax} `;
+            yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
+            yield common_1.endOfLine;
+        }
+    }
+}
+function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors) {
+    if (scriptSetupRanges.props.define?.arg || scriptSetupRanges.emits.define) {
+        yield `const __VLS_fnComponent = `
+            + `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+        if (scriptSetupRanges.props.define?.arg) {
+            yield `	props: `;
+            yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end, index_1.codeFeatures.navigation);
+            yield `,${common_1.newLine}`;
+        }
+        if (scriptSetupRanges.emits.define) {
+            yield `	emits: ({} as __VLS_NormalizeEmits<typeof `;
+            yield scriptSetupRanges.emits.name ?? '__VLS_emit';
+            yield `>),${common_1.newLine}`;
+        }
+        yield `})${common_1.endOfLine}`;
+        yield `let __VLS_functionalComponentProps!: `;
+        yield `${ctx.helperTypes.OmitKeepDiscriminatedUnion.name}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof typeof __VLS_publicProps>`;
+        yield common_1.endOfLine;
+    }
+    else {
+        yield `let __VLS_functionalComponentProps!: {}${common_1.endOfLine}`;
+    }
+    yield `let __VLS_publicProps!:${common_1.newLine}`
+        + `	import('${options.vueCompilerOptions.lib}').VNodeProps${common_1.newLine}`
+        + `	& import('${options.vueCompilerOptions.lib}').AllowedComponentProps${common_1.newLine}`
+        + `	& import('${options.vueCompilerOptions.lib}').ComponentCustomProps${common_1.endOfLine}`;
+    if (scriptSetupRanges.defineProp.length) {
+        yield `const __VLS_defaults = {${common_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            if (defineProp.defaultValue) {
+                if (defineProp.name) {
+                    yield scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                }
+                else {
+                    yield `modelValue`;
+                }
+                yield `: `;
+                yield scriptSetup.content.substring(defineProp.defaultValue.start, defineProp.defaultValue.end);
+                yield `,${common_1.newLine}`;
+            }
+        }
+        yield `}${common_1.endOfLine}`;
+    }
+    yield `let __VLS_componentProps!: `;
+    if (scriptSetupRanges.slots.define && options.vueCompilerOptions.jsxSlots) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `${ctx.helperTypes.PropsChildren.name}<typeof __VLS_slots>`;
+    }
+    if (scriptSetupRanges.defineProp.length) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `{${common_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            let propName = 'modelValue';
+            if (defineProp.name && defineProp.nameIsString) {
+                // renaming support
+                yield (0, common_1.generateSfcBlockSection)(scriptSetup, defineProp.name.start, defineProp.name.end, index_1.codeFeatures.navigation);
+            }
+            else if (defineProp.name) {
+                propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                definePropMirrors.set(propName, options.getGeneratedLength());
+                yield propName;
+            }
+            else {
+                yield propName;
+            }
+            yield defineProp.required
+                ? `: `
+                : `?: `;
+            if (defineProp.type) {
+                yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
+            }
+            else if (!defineProp.nameIsString) {
+                yield `NonNullable<typeof ${propName}['value']>`;
+            }
+            else if (defineProp.defaultValue) {
+                yield `typeof __VLS_defaults['${propName}']`;
+            }
+            else {
+                yield `any`;
+            }
+            yield `,${common_1.newLine}`;
+            if (defineProp.modifierType) {
+                let propModifierName = 'modelModifiers';
+                if (defineProp.name) {
+                    propModifierName = `${scriptSetup.content.substring(defineProp.name.start + 1, defineProp.name.end - 1)}Modifiers`;
+                }
+                const modifierType = scriptSetup.content.substring(defineProp.modifierType.start, defineProp.modifierType.end);
+                definePropMirrors.set(propModifierName, options.getGeneratedLength());
+                yield `${propModifierName}?: Record<${modifierType}, true>,${common_1.endOfLine}`;
+            }
+        }
+        yield `}`;
+    }
+    if (scriptSetupRanges.props.define?.typeArg) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.typeArg.start, scriptSetupRanges.props.define.typeArg.end, index_1.codeFeatures.all);
+    }
+    if (!ctx.generatedPropsType) {
+        yield `{}`;
+    }
+    yield common_1.endOfLine;
+}
+function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
+    yield `let __VLS_modelEmitsType!: {}`;
+    if (scriptSetupRanges.defineProp.length) {
+        yield ` & ReturnType<typeof import('${options.vueCompilerOptions.lib}').defineEmits<{${common_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            if (!defineProp.isModel) {
+                continue;
+            }
+            let propName = 'modelValue';
+            if (defineProp.name) {
+                propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                propName = propName.replace(/['"]+/g, '');
+            }
+            yield `'update:${propName}': [${propName}:`;
+            if (defineProp.type) {
+                yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
+            }
+            else {
+                yield `any`;
+            }
+            yield `]${common_1.endOfLine}`;
+        }
+        yield `}>>`;
+    }
+    yield common_1.endOfLine;
+}
+//# sourceMappingURL=scriptSetup.js.map

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

@@ -0,0 +1,2 @@
+import type { Code, Sfc } from '../../types';
+export declare function generateSrc(script: NonNullable<Sfc['script']>, src: string): Generator<Code>;

package/lib/codegen/script/src.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSrc = void 0;
+const common_1 = require("../common");
+const index_1 = require("./index");
+function* generateSrc(script, src) {
+    if (src.endsWith('.d.ts')) {
+        src = src.substring(0, src.length - '.d.ts'.length);
+    }
+    else if (src.endsWith('.ts')) {
+        src = src.substring(0, src.length - '.ts'.length);
+    }
+    else if (src.endsWith('.tsx')) {
+        src = src.substring(0, src.length - '.tsx'.length) + '.jsx';
+    }
+    if (!src.endsWith('.js') && !src.endsWith('.jsx')) {
+        src = src + '.js';
+    }
+    yield `export * from `;
+    yield [
+        `'${src}'`,
+        'script',
+        script.srcOffset - 1,
+        {
+            ...index_1.codeFeatures.all,
+            navigation: src === script.src
+                ? true
+                : {
+                    shouldRename: () => false,
+                    resolveRenameEditText(newName) {
+                        if (newName.endsWith('.jsx') || newName.endsWith('.js')) {
+                            newName = newName.split('.').slice(0, -1).join('.');
+                        }
+                        if (script?.src?.endsWith('.d.ts')) {
+                            newName = newName + '.d.ts';
+                        }
+                        else if (script?.src?.endsWith('.ts')) {
+                            newName = newName + '.ts';
+                        }
+                        else if (script?.src?.endsWith('.tsx')) {
+                            newName = newName + '.tsx';
+                        }
+                        return newName;
+                    },
+                },
+        },
+    ];
+    yield common_1.endOfLine;
+    yield `export { default } from '${src}'${common_1.endOfLine}`;
+}
+exports.generateSrc = generateSrc;
+//# sourceMappingURL=src.js.map

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

@@ -0,0 +1,5 @@
+import type { Code } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { type ScriptCodegenOptions } from './index';
+export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;
+export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;

package/lib/codegen/script/template.js

@@ -0,0 +1,193 @@
+"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 `/* CSS variable injection */${common_1.newLine}`;
+    yield* generateCssVars(options, templateCodegenCtx);
+    yield `/* CSS variable injection end */${common_1.newLine}`;
+    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) {
+    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;
+        }
+    }
+}
+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>;