@vue/language-core 2.2.0 → 2.2.4

package/lib/utils/ts.js

@@ -1,27 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerOptionsResolver = void 0;
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
+exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
 exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
 exports.setupGlobalTypes = setupGlobalTypes;
 const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("../codegen/globalTypes");
 const languagePlugin_1 = require("../languagePlugin");
+const shared_2 = require("./shared");
 function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json', skipGlobalTypesSetup = false) {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
-    let vueOptions = {};
+    const resolver = new CompilerOptionsResolver();
     for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
         try {
-            vueOptions = {
-                ...vueOptions,
-                ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
-            };
+            const configFile = ts.readJsonConfigFile(extendPath, proxyHost.host.readFile);
+            const obj = ts.convertToObject(configFile, []);
+            const rawOptions = obj?.vueCompilerOptions ?? {};
+            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
         }
         catch (err) { }
     }
-    const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+    const resolvedVueOptions = resolver.build();
     if (skipGlobalTypesSetup) {
         resolvedVueOptions.__setupedGlobalTypes = true;
     }
@@ -48,17 +51,17 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
         const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
         const config = ts.readJsonConfigFile(tsConfigPath, proxyHost.host.readFile);
         ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path_browserify_1.posix.dirname(tsConfigPath), {}, tsConfigPath);
-        let vueOptions = {};
+        const resolver = new CompilerOptionsResolver();
         for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
             try {
-                vueOptions = {
-                    ...vueOptions,
-                    ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
-                };
+                const configFile = ts.readJsonConfigFile(extendPath, proxyHost.host.readFile);
+                const obj = ts.convertToObject(configFile, []);
+                const rawOptions = obj?.vueCompilerOptions ?? {};
+                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
             }
             catch (err) { }
         }
-        const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+        const resolvedVueOptions = resolver.build();
         if (skipGlobalTypesSetup) {
             resolvedVueOptions.__setupedGlobalTypes = true;
         }
@@ -85,7 +88,7 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
         return {
             fileNames: [],
             options: {},
-            vueOptions: resolveVueCompilerOptions({}),
+            vueOptions: getDefaultCompilerOptions(),
             errors: [],
         };
     }
@@ -110,67 +113,104 @@ function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
         extendConfigPaths,
     };
 }
-function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
-    const folder = path_browserify_1.posix.dirname(tsConfigSourceFile.fileName);
-    const obj = ts.convertToObject(tsConfigSourceFile, []);
-    const rawOptions = obj?.vueCompilerOptions ?? {};
-    const result = {
-        ...rawOptions,
-    };
-    const target = rawOptions.target ?? 'auto';
-    if (target === 'auto') {
-        const resolvedPath = resolvePath('vue/package.json');
-        if (resolvedPath) {
-            const vuePackageJson = require(resolvedPath);
-            const versionNumbers = vuePackageJson.version.split('.');
-            result.target = Number(versionNumbers[0] + '.' + versionNumbers[1]);
+class CompilerOptionsResolver {
+    constructor() {
+        this.options = {};
+        this.plugins = [];
+    }
+    addConfig(options, rootDir) {
+        for (const key in options) {
+            switch (key) {
+                case 'target':
+                    const target = options.target;
+                    if (typeof target === 'string') {
+                        this.target = findVueVersion(rootDir);
+                    }
+                    else {
+                        this.target = target;
+                    }
+                    break;
+                case 'plugins':
+                    this.plugins = (options.plugins ?? [])
+                        .map((pluginPath) => {
+                        try {
+                            const resolvedPath = resolvePath(pluginPath, rootDir);
+                            if (resolvedPath) {
+                                const plugin = require(resolvedPath);
+                                plugin.__moduleName = pluginPath;
+                                return plugin;
+                            }
+                            else {
+                                console.warn('[Vue] Load plugin failed:', pluginPath);
+                            }
+                        }
+                        catch (error) {
+                            console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
+                        }
+                        return [];
+                    });
+                    break;
+                default:
+                    // @ts-expect-error
+                    this.options[key] = options[key];
+                    break;
+            }
         }
-        else {
-            // console.warn('Load vue/package.json failed from', folder);
+        if (this.target === undefined) {
+            this.fallbackTarget = findVueVersion(rootDir);
         }
     }
-    else {
-        result.target = target;
+    build(defaults) {
+        const target = this.target ?? this.fallbackTarget;
+        defaults ??= getDefaultCompilerOptions(target, this.options.lib, this.options.strictTemplates);
+        return {
+            ...defaults,
+            ...this.options,
+            plugins: this.plugins,
+            macros: {
+                ...defaults.macros,
+                ...this.options.macros,
+            },
+            composables: {
+                ...defaults.composables,
+                ...this.options.composables,
+            },
+            fallthroughComponentNames: [
+                ...defaults.fallthroughComponentNames,
+                ...this.options.fallthroughComponentNames ?? []
+            ].map(shared_2.hyphenateTag),
+            // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
+            // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
+            experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
+        };
     }
-    if (rawOptions.plugins) {
-        const plugins = rawOptions.plugins
-            .map((pluginPath) => {
-            try {
-                const resolvedPath = resolvePath(pluginPath);
-                if (resolvedPath) {
-                    const plugin = require(resolvedPath);
-                    plugin.__moduleName = pluginPath;
-                    return plugin;
-                }
-                else {
-                    console.warn('[Vue] Load plugin failed:', pluginPath);
-                }
-            }
-            catch (error) {
-                console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
-            }
-            return [];
-        });
-        result.plugins = plugins;
+}
+exports.CompilerOptionsResolver = CompilerOptionsResolver;
+function findVueVersion(rootDir) {
+    const resolvedPath = resolvePath('vue/package.json', rootDir);
+    if (resolvedPath) {
+        const vuePackageJson = require(resolvedPath);
+        const versionNumbers = vuePackageJson.version.split('.');
+        return Number(versionNumbers[0] + '.' + versionNumbers[1]);
     }
-    return result;
-    function resolvePath(scriptPath) {
-        try {
-            if (require?.resolve) {
-                return require.resolve(scriptPath, { paths: [folder] });
-            }
-            else {
-                // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
-            }
+    else {
+        // console.warn('Load vue/package.json failed from', folder);
+    }
+}
+function resolvePath(scriptPath, root) {
+    try {
+        if (require?.resolve) {
+            return require.resolve(scriptPath, { paths: [root] });
         }
-        catch (error) {
-            // console.warn(error);
+        else {
+            // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
         }
     }
+    catch (error) {
+        // console.warn(error);
+    }
 }
-function getDefaultOptions(options) {
-    const target = options.target ?? 3.3;
-    const lib = options.lib ?? 'vue';
+function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false) {
     return {
         target,
         lib,
@@ -178,9 +218,24 @@ function getDefaultOptions(options) {
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
-        strictTemplates: false,
+        checkUnknownProps: strictTemplates,
+        checkUnknownEvents: strictTemplates,
+        checkUnknownDirectives: strictTemplates,
+        checkUnknownComponents: strictTemplates,
+        inferComponentDollarEl: false,
+        inferComponentDollarRefs: false,
+        inferTemplateDollarAttrs: false,
+        inferTemplateDollarEl: false,
+        inferTemplateDollarRefs: false,
+        inferTemplateDollarSlots: false,
         skipTemplateCodegen: false,
         fallthroughAttributes: false,
+        fallthroughComponentNames: [
+            'Transition',
+            'KeepAlive',
+            'Teleport',
+            'Suspense',
+        ],
         dataAttributes: [],
         htmlAttributes: ['aria-*'],
         optionsWrapper: target >= 2.7
@@ -204,25 +259,7 @@ function getDefaultOptions(options) {
         plugins: [],
         experimentalDefinePropProposal: false,
         experimentalResolveStyleCssClasses: 'scoped',
-        experimentalModelPropName: null
-    };
-}
-;
-function resolveVueCompilerOptions(options, defaults = getDefaultOptions(options)) {
-    return {
-        ...defaults,
-        ...options,
-        macros: {
-            ...defaults.macros,
-            ...options.macros,
-        },
-        composables: {
-            ...defaults.composables,
-            ...options.composables,
-        },
-        // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
-        // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
-        experimentalModelPropName: Object.fromEntries(Object.entries(options.experimentalModelPropName ?? defaults.experimentalModelPropName ?? {
+        experimentalModelPropName: {
             '': {
                 input: true
             },
@@ -231,7 +268,16 @@ function resolveVueCompilerOptions(options, defaults = getDefaultOptions(options
                 textarea: true,
                 select: true
             }
-        }).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
+        },
+    };
+}
+/**
+ * @deprecated use `getDefaultCompilerOptions` instead
+ */
+function resolveVueCompilerOptions(options) {
+    return {
+        ...getDefaultCompilerOptions(options.target, options.lib),
+        ...options,
     };
 }
 function setupGlobalTypes(rootDir, vueOptions, host) {
@@ -247,8 +293,8 @@ function setupGlobalTypes(rootDir, vueOptions, host) {
             }
             dir = parentDir;
         }
-        const globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', `${vueOptions.lib}_${vueOptions.target}_${vueOptions.strictTemplates}.d.ts`);
-        const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, globalTypes_1.generateGlobalTypes)(vueOptions.lib, vueOptions.target, vueOptions.strictTemplates);
+        const globalTypesPath = path_browserify_1.posix.join(dir, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(vueOptions));
+        const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, globalTypes_1.generateGlobalTypes)(vueOptions);
         host.writeFile(globalTypesPath, globalTypesContents);
         return { absolutePath: globalTypesPath };
     }

package/lib/virtualFile/computedEmbeddedCodes.d.ts

@@ -1,4 +1,4 @@
 import type { VirtualCode } from '@volar/language-core';
 import type { Sfc, VueLanguagePluginReturn } from '../types';
-export declare function computedEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): import("alien-signals").Computed<VirtualCode[]>;
+export declare function computedEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
 export declare function resolveCommonLanguageId(lang: string): string;

package/lib/virtualFile/computedEmbeddedCodes.js

@@ -7,7 +7,7 @@ const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 const embeddedFile_1 = require("./embeddedFile");
 function computedEmbeddedCodes(plugins, fileName, sfc) {
-    const nameToBlock = (0, alien_signals_1.computed)(() => {
+    const getNameToBlockMap = (0, alien_signals_1.computed)(() => {
         const blocks = {};
         if (sfc.template) {
             blocks[sfc.template.name] = sfc.template;
@@ -26,11 +26,11 @@ function computedEmbeddedCodes(plugins, fileName, sfc) {
         }
         return blocks;
     });
-    const pluginsResult = plugins.map(plugin => computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock));
-    const flatResult = (0, alien_signals_1.computed)(() => pluginsResult.map(r => r.get()).flat());
-    const structuredResult = (0, alien_signals_1.computed)(() => {
+    const getPluginsResult = plugins.map(plugin => computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, name => getNameToBlockMap()[name]));
+    const getFlatResult = (0, alien_signals_1.computed)(() => getPluginsResult.map(r => r()).flat());
+    const getStructuredResult = (0, alien_signals_1.computed)(() => {
         const embeddedCodes = [];
-        let remain = [...flatResult.get()];
+        let remain = [...getFlatResult()];
         while (remain.length) {
             const beforeLength = remain.length;
             consumeRemain();
@@ -85,12 +85,12 @@ function computedEmbeddedCodes(plugins, fileName, sfc) {
             }
         }
     });
-    return structuredResult;
+    return getStructuredResult;
 }
-function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock) {
+function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByName) {
     const computeds = new Map();
     const getComputedKey = (code) => code.id + '__' + code.lang;
-    const codes = (0, alien_signals_1.computed)(() => {
+    const getCodes = (0, alien_signals_1.computed)(() => {
         try {
             if (!plugin.getEmbeddedCodes) {
                 return [...computeds.values()];
@@ -148,8 +148,8 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock
         return [...computeds.values()];
     });
     return (0, alien_signals_1.computed)(() => {
-        return codes.get().map(_file => {
-            const { code, snapshot } = _file.get();
+        return getCodes().map(_file => {
+            const { code, snapshot } = _file();
             const mappings = (0, buildMappings_1.buildMappings)(code.content.map(segment => {
                 if (typeof segment === 'string') {
                     return segment;
@@ -158,7 +158,7 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock
                 if (source === undefined) {
                     return segment;
                 }
-                const block = nameToBlock.get()[source];
+                const block = getBlockByName(source);
                 if (!block) {
                     // console.warn('Unable to find block: ' + source);
                     return segment;
@@ -171,28 +171,18 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, nameToBlock
                 ];
             }));
             const newMappings = [];
-            let lastValidMapping;
             for (let i = 0; i < mappings.length; i++) {
                 const mapping = mappings[i];
-                if (mapping.data.__combineOffsetMapping !== undefined) {
-                    const offsetMapping = mappings[i - mapping.data.__combineOffsetMapping];
+                if (mapping.data.__combineOffset !== undefined) {
+                    const offsetMapping = mappings[i - mapping.data.__combineOffset];
                     if (typeof offsetMapping === 'string' || !offsetMapping) {
-                        throw new Error('Invalid offset mapping, mappings: ' + mappings.length + ', i: ' + i + ', offset: ' + mapping.data.__combineOffsetMapping);
+                        throw new Error('Invalid offset mapping, mappings: ' + mappings.length + ', i: ' + i + ', offset: ' + mapping.data.__combineOffset);
                     }
                     offsetMapping.sourceOffsets.push(...mapping.sourceOffsets);
                     offsetMapping.generatedOffsets.push(...mapping.generatedOffsets);
                     offsetMapping.lengths.push(...mapping.lengths);
                     continue;
                 }
-                else if (mapping.data.__combineLastMapping) {
-                    lastValidMapping.sourceOffsets.push(...mapping.sourceOffsets);
-                    lastValidMapping.generatedOffsets.push(...mapping.generatedOffsets);
-                    lastValidMapping.lengths.push(...mapping.lengths);
-                    continue;
-                }
-                else {
-                    lastValidMapping = mapping;
-                }
                 newMappings.push(mapping);
             }
             return {

package/lib/virtualFile/computedSfc.d.ts

@@ -1,5 +1,4 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
-import { ISignal, Signal } from 'alien-signals';
 import type * as ts from 'typescript';
 import type { Sfc, VueLanguagePluginReturn } from '../types';
-export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, snapshot: Signal<ts.IScriptSnapshot>, parsed: ISignal<SFCParseResult | undefined>): Sfc;
+export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, getSnapshot: () => ts.IScriptSnapshot, getParseResult: () => SFCParseResult | undefined): Sfc;