@vue/language-core 3.0.7 → 3.0.9

package/lib/virtualFile/vueFile.d.ts

@@ -1,6 +1,7 @@
-import type { VirtualCode } from '@volar/language-core';
+import type { CodeInformation, Mapping, VirtualCode } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions, VueLanguagePluginReturn } from '../types';
+import { computedSfc } from './computedSfc';
 export declare class VueVirtualCode implements VirtualCode {
     fileName: string;
     languageId: string;
@@ -8,22 +9,16 @@ export declare class VueVirtualCode implements VirtualCode {
     vueCompilerOptions: VueCompilerOptions;
     plugins: VueLanguagePluginReturn[];
     ts: typeof import('typescript');
-    id: string;
+    readonly id = "main";
+    readonly sfc: ReturnType<typeof computedSfc>;
     private _snapshot;
     private _vueSfc;
-    private _sfc;
     private _embeddedCodes;
     private _mappings;
     get snapshot(): ts.IScriptSnapshot;
     get vueSfc(): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    get sfc(): import("../types").Sfc;
     get embeddedCodes(): VirtualCode[];
-    get mappings(): {
-        sourceOffsets: number[];
-        generatedOffsets: number[];
-        lengths: number[];
-        data: import("@volar/language-core").CodeInformation;
-    }[];
+    get mappings(): Mapping<CodeInformation>[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: VueLanguagePluginReturn[], ts: typeof import('typescript'));
     update(newSnapshot: ts.IScriptSnapshot): void;
 }

package/lib/virtualFile/vueFile.js

@@ -7,16 +7,12 @@ const computedEmbeddedCodes_1 = require("./computedEmbeddedCodes");
 const computedSfc_1 = require("./computedSfc");
 const computedVueSfc_1 = require("./computedVueSfc");
 class VueVirtualCode {
-    // others
     get snapshot() {
         return this._snapshot();
     }
     get vueSfc() {
         return this._vueSfc();
     }
-    get sfc() {
-        return this._sfc;
-    }
     get embeddedCodes() {
         return this._embeddedCodes();
     }
@@ -30,13 +26,11 @@ class VueVirtualCode {
         this.vueCompilerOptions = vueCompilerOptions;
         this.plugins = plugins;
         this.ts = ts;
-        // sources
         this.id = 'main';
-        this._snapshot = (0, alien_signals_1.signal)(undefined);
-        // computeds
+        this._snapshot = (0, alien_signals_1.signal)(initSnapshot);
         this._vueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, this.languageId, this._snapshot);
-        this._sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, this._snapshot, this._vueSfc);
-        this._embeddedCodes = (0, computedEmbeddedCodes_1.computedEmbeddedCodes)(this.plugins, this.fileName, this._sfc);
+        this.sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, this._snapshot, this._vueSfc);
+        this._embeddedCodes = (0, computedEmbeddedCodes_1.computedEmbeddedCodes)(this.plugins, this.fileName, this.sfc);
         this._mappings = (0, alien_signals_1.computed)(() => {
             const snapshot = this._snapshot();
             return [{
@@ -46,7 +40,6 @@ class VueVirtualCode {
                     data: plugins_1.allCodeFeatures,
                 }];
         });
-        this._snapshot(initSnapshot);
     }
     update(newSnapshot) {
         this._snapshot(newSnapshot);

package/package.json

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

package/lib/codegen/tenp.d.ts

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

package/lib/codegen/tenp.js

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

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

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

package/lib/plugins/file-css.js

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

package/lib/utils/parseCssClassNames.d.ts

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

package/lib/utils/parseCssClassNames.js

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

package/lib/utils/parseCssImports.d.ts

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

package/lib/utils/parseCssImports.js

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

package/lib/utils/parseCssVars.d.ts

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

package/lib/utils/parseCssVars.js

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

package/lib/utils/ts.d.ts

@@ -1,24 +0,0 @@
-import type * as ts from 'typescript';
-import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from '../types';
-interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
-}
-export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
-    vueOptions: VueCompilerOptions;
-}
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), host: ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), host: ParseConfigHost, configFileName: string): ParsedCommandLine;
-export declare class CompilerOptionsResolver {
-    fileExists?: ((path: string) => boolean) | undefined;
-    configRoots: Set<string>;
-    options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
-    target: number | undefined;
-    globalTypesPath: string | undefined;
-    plugins: VueLanguagePlugin[];
-    constructor(fileExists?: ((path: string) => boolean) | undefined);
-    addConfig(options: RawVueCompilerOptions, rootDir: string): void;
-    build(defaults?: VueCompilerOptions): VueCompilerOptions;
-    private findNodeModulesRoot;
-}
-export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
-export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
-export {};

package/lib/utils/ts.js

@@ -1,296 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompilerOptionsResolver = void 0;
-exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
-exports.createParsedCommandLine = createParsedCommandLine;
-exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
-exports.writeGlobalTypes = writeGlobalTypes;
-const shared_1 = require("@vue/shared");
-const path_browserify_1 = require("path-browserify");
-const globalTypes_1 = require("../codegen/globalTypes");
-const shared_2 = require("./shared");
-function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
-    const extendedPaths = new Set();
-    const proxyHost = {
-        ...host,
-        readFile(fileName) {
-            if (!fileName.endsWith('/package.json')) {
-                extendedPaths.add(fileName);
-            }
-            return host.readFile(fileName);
-        },
-        readDirectory() {
-            return [];
-        },
-    };
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost, rootDir, {}, configFileName);
-    const resolver = new CompilerOptionsResolver(host.fileExists);
-    for (const extendPath of [...extendedPaths].reverse()) {
-        try {
-            const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-            const obj = ts.convertToObject(configFile, []);
-            const rawOptions = obj?.vueCompilerOptions ?? {};
-            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
-        }
-        catch { }
-    }
-    // ensure the rootDir is added to the config roots
-    resolver.addConfig({}, rootDir);
-    return {
-        ...parsed,
-        vueOptions: resolver.build(),
-    };
-}
-function createParsedCommandLine(ts, host, configFileName) {
-    try {
-        const extendedPaths = new Set();
-        const proxyHost = {
-            ...host,
-            readFile(fileName) {
-                if (!fileName.endsWith('/package.json')) {
-                    extendedPaths.add(fileName);
-                }
-                return host.readFile(fileName);
-            },
-            readDirectory() {
-                return [];
-            },
-        };
-        const config = ts.readJsonConfigFile(configFileName, proxyHost.readFile);
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
-        const resolver = new CompilerOptionsResolver(host.fileExists);
-        for (const extendPath of [...extendedPaths].reverse()) {
-            try {
-                const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-                const obj = ts.convertToObject(configFile, []);
-                const rawOptions = obj?.vueCompilerOptions ?? {};
-                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
-            }
-            catch { }
-        }
-        return {
-            ...parsed,
-            vueOptions: resolver.build(),
-        };
-    }
-    catch { }
-    return {
-        options: {},
-        errors: [],
-        vueOptions: getDefaultCompilerOptions(),
-    };
-}
-class CompilerOptionsResolver {
-    constructor(fileExists) {
-        this.fileExists = fileExists;
-        this.configRoots = new Set();
-        this.options = {};
-        this.plugins = [];
-    }
-    addConfig(options, rootDir) {
-        this.configRoots.add(rootDir);
-        for (const key in options) {
-            switch (key) {
-                case 'target':
-                    if (options[key] === 'auto') {
-                        this.target = findVueVersion(rootDir);
-                    }
-                    else {
-                        this.target = options[key];
-                    }
-                    break;
-                case 'globalTypesPath':
-                    if (options[key] !== undefined) {
-                        this.globalTypesPath = path_browserify_1.posix.join(rootDir, options[key]);
-                    }
-                    break;
-                case 'plugins':
-                    this.plugins = (options.plugins ?? [])
-                        .flatMap((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;
-            }
-        }
-        if (options.target === undefined) {
-            this.target ??= findVueVersion(rootDir);
-        }
-    }
-    build(defaults) {
-        defaults ??= getDefaultCompilerOptions(this.target, this.options.lib, this.options.strictTemplates);
-        const resolvedOptions = {
-            ...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 (resolvedOptions.globalTypesPath === shared_1.NOOP) {
-            if (this.fileExists && this.globalTypesPath === undefined) {
-                const fileDirToGlobalTypesPath = new Map();
-                resolvedOptions.globalTypesPath = fileName => {
-                    const fileDir = path_browserify_1.posix.dirname(fileName);
-                    if (fileDirToGlobalTypesPath.has(fileDir)) {
-                        return fileDirToGlobalTypesPath.get(fileDir);
-                    }
-                    const root = this.findNodeModulesRoot(fileDir, resolvedOptions.lib);
-                    const result = root
-                        ? path_browserify_1.posix.join(root, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions))
-                        : undefined;
-                    fileDirToGlobalTypesPath.set(fileDir, result);
-                    return result;
-                };
-            }
-            else {
-                resolvedOptions.globalTypesPath = () => this.globalTypesPath;
-            }
-        }
-        return resolvedOptions;
-    }
-    findNodeModulesRoot(dir, lib) {
-        while (!this.fileExists(path_browserify_1.posix.join(dir, 'node_modules', lib, 'package.json'))) {
-            const parentDir = path_browserify_1.posix.dirname(dir);
-            if (dir === parentDir) {
-                return;
-            }
-            dir = parentDir;
-        }
-        return dir;
-    }
-}
-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]);
-    }
-    else {
-        // console.warn('Load vue/package.json failed from', folder);
-    }
-}
-function resolvePath(scriptPath, root) {
-    try {
-        if (require?.resolve) {
-            return require.resolve(scriptPath, { paths: [root] });
-        }
-        else {
-            // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
-        }
-    }
-    catch {
-        // console.warn(error);
-    }
-}
-function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false) {
-    return {
-        target,
-        lib,
-        globalTypesPath: shared_1.NOOP,
-        extensions: ['.vue'],
-        vitePressExtensions: [],
-        petiteVueExtensions: [],
-        jsxSlots: false,
-        strictVModel: strictTemplates,
-        strictCssModules: 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,
-        resolveStyleImports: false,
-        resolveStyleClassNames: 'scoped',
-        fallthroughComponentNames: [
-            'Transition',
-            'KeepAlive',
-            'Teleport',
-            'Suspense',
-        ],
-        dataAttributes: [],
-        htmlAttributes: ['aria-*'],
-        optionsWrapper: target >= 2.7
-            ? [`(await import('${lib}')).defineComponent(`, `)`]
-            : [`(await import('${lib}')).default.extend(`, `)`],
-        macros: {
-            defineProps: ['defineProps'],
-            defineSlots: ['defineSlots'],
-            defineEmits: ['defineEmits'],
-            defineExpose: ['defineExpose'],
-            defineModel: ['defineModel'],
-            defineOptions: ['defineOptions'],
-            withDefaults: ['withDefaults'],
-        },
-        composables: {
-            useAttrs: ['useAttrs'],
-            useCssModule: ['useCssModule'],
-            useSlots: ['useSlots'],
-            useTemplateRef: ['useTemplateRef', 'templateRef'],
-        },
-        plugins: [],
-        experimentalModelPropName: {
-            '': {
-                input: true,
-            },
-            value: {
-                input: { type: 'text' },
-                textarea: true,
-                select: true,
-            },
-        },
-    };
-}
-function writeGlobalTypes(vueOptions, writeFile) {
-    const originalFn = vueOptions.globalTypesPath;
-    if (!originalFn) {
-        return;
-    }
-    const writed = new Set();
-    vueOptions.globalTypesPath = (fileName) => {
-        const result = originalFn(fileName);
-        if (result && !writed.has(result)) {
-            writed.add(result);
-            writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));
-        }
-        return result;
-    };
-}
-//# sourceMappingURL=ts.js.map