@vue/language-core 3.1.6 → 3.1.8

package/lib/virtualFile/computedSfc.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateInlineTsAsts = void 0;
+exports.computedSfc = computedSfc;
+const CompilerDOM = require("@vue/compiler-dom");
+const alien_signals_1 = require("alien-signals");
+const signals_1 = require("../utils/signals");
+exports.templateInlineTsAsts = new WeakMap();
+function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
+    const getUntrackedSnapshot = () => {
+        const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
+        const res = getSnapshot();
+        (0, alien_signals_1.setActiveSub)(pausedSub);
+        return res;
+    };
+    const getContent = (0, alien_signals_1.computed)(() => {
+        return getSnapshot().getText(0, getSnapshot().getLength());
+    });
+    const getComments = (0, alien_signals_1.computed)(oldValue => {
+        const newValue = getParseResult()?.descriptor.comments ?? [];
+        if (oldValue?.length === newValue.length
+            && oldValue.every((v, i) => v === newValue[i])) {
+            return oldValue;
+        }
+        return newValue;
+    });
+    const getTemplate = computedNullableSfcBlock('template', 'html', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.template ?? undefined), (_block, base) => {
+        const compiledAst = computedTemplateAst(base);
+        return mergeObject(base, {
+            get ast() {
+                return compiledAst().ast;
+            },
+            get errors() {
+                return compiledAst().errors;
+            },
+            get warnings() {
+                return compiledAst().warnings;
+            },
+        });
+    });
+    const getScript = computedNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.script ?? undefined), (block, base) => {
+        const getSrc = computedAttrValue('__src', base, block);
+        const getAst = (0, alien_signals_1.computed)(() => {
+            for (const plugin of plugins) {
+                const ast = plugin.compileSFCScript?.(base.lang, base.content);
+                if (ast) {
+                    return ast;
+                }
+            }
+            return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
+        });
+        return mergeObject(base, {
+            get src() {
+                return getSrc();
+            },
+            get ast() {
+                return getAst();
+            },
+        });
+    });
+    const getOriginalScriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.scriptSetup ?? undefined), (block, base) => {
+        const getGeneric = computedAttrValue('__generic', base, block);
+        const getAst = (0, alien_signals_1.computed)(() => {
+            for (const plugin of plugins) {
+                const ast = plugin.compileSFCScript?.(base.lang, base.content);
+                if (ast) {
+                    return ast;
+                }
+            }
+            return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
+        });
+        return mergeObject(base, {
+            get generic() {
+                return getGeneric();
+            },
+            get ast() {
+                return getAst();
+            },
+        });
+    });
+    const hasScript = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.script);
+    const hasScriptSetup = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.scriptSetup);
+    const getScriptSetup = (0, alien_signals_1.computed)(() => {
+        if (!hasScript() && !hasScriptSetup()) {
+            // #region monkey fix: https://github.com/vuejs/language-tools/pull/2113
+            return {
+                content: '',
+                lang: 'ts',
+                name: '',
+                start: 0,
+                end: 0,
+                startTagEnd: 0,
+                endTagStart: 0,
+                generic: undefined,
+                genericOffset: 0,
+                attrs: {},
+                ast: ts.createSourceFile('', '', 99, false, ts.ScriptKind.TS),
+            };
+        }
+        return getOriginalScriptSetup();
+    });
+    const styles = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.styles ?? []), (getBlock, i) => {
+        const base = computedSfcBlock('style_' + i, 'css', getBlock);
+        const getSrc = computedAttrValue('__src', base, getBlock);
+        const getModule = computedAttrValue('__module', base, getBlock);
+        const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
+        const getIr = (0, alien_signals_1.computed)(() => {
+            for (const plugin of plugins) {
+                const ast = plugin.compileSFCStyle?.(base.lang, base.content);
+                if (ast) {
+                    return ast;
+                }
+            }
+        });
+        const getImports = (0, signals_1.computedItems)(() => getIr()?.imports ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        const getBindings = (0, signals_1.computedItems)(() => getIr()?.bindings ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        const getClassNames = (0, signals_1.computedItems)(() => getIr()?.classNames ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        return () => mergeObject(base, {
+            get src() {
+                return getSrc();
+            },
+            get module() {
+                return getModule();
+            },
+            get scoped() {
+                return getScoped();
+            },
+            get imports() {
+                return getImports();
+            },
+            get bindings() {
+                return getBindings();
+            },
+            get classNames() {
+                return getClassNames();
+            },
+        });
+    });
+    const customBlocks = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.customBlocks ?? []), (getBlock, i) => {
+        const base = computedSfcBlock('custom_block_' + i, 'txt', getBlock);
+        const getType = (0, alien_signals_1.computed)(() => getBlock().type);
+        return () => mergeObject(base, {
+            get type() {
+                return getType();
+            },
+        });
+    });
+    return {
+        get content() {
+            return getContent();
+        },
+        get comments() {
+            return getComments();
+        },
+        get template() {
+            return getTemplate();
+        },
+        get script() {
+            return getScript();
+        },
+        get scriptSetup() {
+            return getScriptSetup();
+        },
+        get styles() {
+            return styles;
+        },
+        get customBlocks() {
+            return customBlocks;
+        },
+    };
+    function computedTemplateAst(base) {
+        let cache;
+        let inlineTsAsts;
+        function updateInlineTsAsts(newAst, oldAst) {
+            let newTsAsts = exports.templateInlineTsAsts.get(newAst);
+            if (!newTsAsts) {
+                exports.templateInlineTsAsts.set(newAst, newTsAsts = new Map());
+            }
+            const oldTsAsts = oldAst && exports.templateInlineTsAsts.get(oldAst) || inlineTsAsts;
+            if (oldTsAsts) {
+                for (const [text, ast] of oldTsAsts) {
+                    if (!ast.__volar_used) {
+                        oldTsAsts.delete(text);
+                    }
+                    else {
+                        newTsAsts.set(text, ast);
+                        ast.__volar_used = false;
+                    }
+                }
+            }
+            inlineTsAsts = new Map(newTsAsts);
+        }
+        return (0, alien_signals_1.computed)(() => {
+            if (cache?.template === base.content) {
+                return {
+                    errors: [],
+                    warnings: [],
+                    ast: cache.result.ast,
+                };
+            }
+            // incremental update
+            if (cache?.plugin.updateSFCTemplate) {
+                const change = getUntrackedSnapshot().getChangeRange(cache.snapshot);
+                if (change) {
+                    const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
+                    const templateOffset = base.startTagEnd;
+                    (0, alien_signals_1.setActiveSub)(pausedSub);
+                    const newText = getUntrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
+                    const newResult = cache.plugin.updateSFCTemplate(cache.result, {
+                        start: change.span.start - templateOffset,
+                        end: change.span.start + change.span.length - templateOffset,
+                        newText,
+                    });
+                    if (newResult) {
+                        updateInlineTsAsts(newResult.ast, cache.result.ast);
+                        cache.template = base.content;
+                        cache.snapshot = getUntrackedSnapshot();
+                        cache.result = newResult;
+                        return {
+                            errors: [],
+                            warnings: [],
+                            ast: newResult.ast,
+                        };
+                    }
+                }
+            }
+            const errors = [];
+            const warnings = [];
+            const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset();
+            let options = {
+                onError: err => errors.push(err),
+                onWarn: err => warnings.push(err),
+                expressionPlugins: ['typescript'],
+                nodeTransforms,
+                directiveTransforms,
+            };
+            for (const plugin of plugins) {
+                if (plugin.resolveTemplateCompilerOptions) {
+                    options = plugin.resolveTemplateCompilerOptions(options);
+                }
+            }
+            for (const plugin of plugins) {
+                let result;
+                try {
+                    result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
+                    if (result) {
+                        updateInlineTsAsts(result.ast, cache?.result.ast);
+                    }
+                }
+                catch (e) {
+                    const err = e;
+                    errors.push(err);
+                }
+                if (result || errors.length) {
+                    if (result && !errors.length && !warnings.length) {
+                        cache = {
+                            template: base.content,
+                            snapshot: getUntrackedSnapshot(),
+                            result: result,
+                            plugin,
+                        };
+                    }
+                    else {
+                        cache = undefined;
+                    }
+                    return {
+                        errors,
+                        warnings,
+                        ast: result?.ast,
+                    };
+                }
+            }
+            return {
+                errors,
+                warnings,
+                ast: undefined,
+            };
+        });
+    }
+    function computedNullableSfcBlock(name, defaultLang, getBlock, resolve) {
+        const hasBlock = (0, alien_signals_1.computed)(() => !!getBlock());
+        return (0, alien_signals_1.computed)(() => {
+            if (!hasBlock()) {
+                return;
+            }
+            const _block = (0, alien_signals_1.computed)(() => getBlock());
+            return resolve(_block, computedSfcBlock(name, defaultLang, _block));
+        });
+    }
+    function computedSfcBlock(name, defaultLang, getBlock) {
+        const getLang = (0, alien_signals_1.computed)(() => getBlock().lang ?? defaultLang);
+        const getAttrs = (0, alien_signals_1.computed)(() => getBlock().attrs); // TODO: computed it
+        const getContent = (0, alien_signals_1.computed)(() => getBlock().content);
+        const getStartTagEnd = (0, alien_signals_1.computed)(() => getBlock().loc.start.offset);
+        const getEndTagStart = (0, alien_signals_1.computed)(() => getBlock().loc.end.offset);
+        const getStart = (0, alien_signals_1.computed)(() => getUntrackedSnapshot().getText(0, getStartTagEnd()).lastIndexOf('<' + getBlock().type));
+        const getEnd = (0, alien_signals_1.computed)(() => getEndTagStart()
+            + getUntrackedSnapshot().getText(getEndTagStart(), getUntrackedSnapshot().getLength()).indexOf('>') + 1);
+        return {
+            name,
+            get lang() {
+                return getLang();
+            },
+            get attrs() {
+                return getAttrs();
+            },
+            get content() {
+                return getContent();
+            },
+            get startTagEnd() {
+                return getStartTagEnd();
+            },
+            get endTagStart() {
+                return getEndTagStart();
+            },
+            get start() {
+                return getStart();
+            },
+            get end() {
+                return getEnd();
+            },
+        };
+    }
+    function computedAttrValue(key, base, getBlock) {
+        return (0, alien_signals_1.computed)(() => {
+            const val = getBlock()[key];
+            if (typeof val === 'object') {
+                return {
+                    ...val,
+                    offset: base.start + val.offset,
+                };
+            }
+            return val;
+        });
+    }
+}
+function mergeObject(a, b) {
+    return Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));
+}
+//# sourceMappingURL=computedSfc.js.map

package/lib/virtualFile/computedVueSfc.d.ts

@@ -0,0 +1,4 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript';
+import type { VueLanguagePluginReturn } from '../types';
+export declare function computedVueSfc(plugins: VueLanguagePluginReturn[], fileName: string, languageId: string, getSnapshot: () => ts.IScriptSnapshot): () => SFCParseResult | undefined;

package/lib/virtualFile/computedVueSfc.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedVueSfc = computedVueSfc;
+const alien_signals_1 = require("alien-signals");
+function computedVueSfc(plugins, fileName, languageId, getSnapshot) {
+    let cache;
+    return (0, alien_signals_1.computed)(() => {
+        // incremental update
+        if (cache?.plugin.updateSFC) {
+            const change = getSnapshot().getChangeRange(cache.snapshot);
+            if (change) {
+                const newSfc = cache.plugin.updateSFC(cache.sfc, {
+                    start: change.span.start,
+                    end: change.span.start + change.span.length,
+                    newText: getSnapshot().getText(change.span.start, change.span.start + change.newLength),
+                });
+                if (newSfc) {
+                    cache.snapshot = getSnapshot();
+                    // force dirty
+                    cache.sfc = JSON.parse(JSON.stringify(newSfc));
+                    return cache.sfc;
+                }
+            }
+        }
+        for (const plugin of plugins) {
+            const sfc = plugin.parseSFC?.(fileName, getSnapshot().getText(0, getSnapshot().getLength()))
+                ?? plugin.parseSFC2?.(fileName, languageId, getSnapshot().getText(0, getSnapshot().getLength()));
+            if (sfc) {
+                if (!sfc.errors.length) {
+                    cache = {
+                        snapshot: getSnapshot(),
+                        sfc,
+                        plugin,
+                    };
+                }
+                return sfc;
+            }
+        }
+    });
+}
+//# sourceMappingURL=computedVueSfc.js.map

package/lib/virtualFile/embeddedFile.d.ts

@@ -0,0 +1,11 @@
+import type { Mapping } from '@volar/language-core';
+import type { Code } from '../types';
+export declare class VueEmbeddedCode {
+    id: string;
+    lang: string;
+    content: Code[];
+    parentCodeId?: string;
+    linkedCodeMappings: Mapping[];
+    embeddedCodes: VueEmbeddedCode[];
+    constructor(id: string, lang: string, content: Code[]);
+}

package/lib/virtualFile/embeddedFile.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueEmbeddedCode = void 0;
+class VueEmbeddedCode {
+    constructor(id, lang, content) {
+        this.id = id;
+        this.lang = lang;
+        this.content = content;
+        this.linkedCodeMappings = [];
+        this.embeddedCodes = [];
+    }
+}
+exports.VueEmbeddedCode = VueEmbeddedCode;
+//# sourceMappingURL=embeddedFile.js.map

package/lib/virtualFile/vueFile.d.ts

@@ -0,0 +1,24 @@
+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;
+    initSnapshot: ts.IScriptSnapshot;
+    vueCompilerOptions: VueCompilerOptions;
+    plugins: VueLanguagePluginReturn[];
+    ts: typeof import('typescript');
+    readonly id = "main";
+    readonly sfc: ReturnType<typeof computedSfc>;
+    private _snapshot;
+    private _vueSfc;
+    private _embeddedCodes;
+    private _mappings;
+    get snapshot(): ts.IScriptSnapshot;
+    get vueSfc(): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    get embeddedCodes(): VirtualCode[];
+    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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueVirtualCode = void 0;
+const alien_signals_1 = require("alien-signals");
+const plugins_1 = require("../plugins");
+const computedEmbeddedCodes_1 = require("./computedEmbeddedCodes");
+const computedSfc_1 = require("./computedSfc");
+const computedVueSfc_1 = require("./computedVueSfc");
+class VueVirtualCode {
+    get snapshot() {
+        return this._snapshot();
+    }
+    get vueSfc() {
+        return this._vueSfc();
+    }
+    get embeddedCodes() {
+        return this._embeddedCodes();
+    }
+    get mappings() {
+        return this._mappings();
+    }
+    constructor(fileName, languageId, initSnapshot, vueCompilerOptions, plugins, ts) {
+        this.fileName = fileName;
+        this.languageId = languageId;
+        this.initSnapshot = initSnapshot;
+        this.vueCompilerOptions = vueCompilerOptions;
+        this.plugins = plugins;
+        this.ts = ts;
+        this.id = 'main';
+        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._mappings = (0, alien_signals_1.computed)(() => {
+            const snapshot = this._snapshot();
+            return [{
+                    sourceOffsets: [0],
+                    generatedOffsets: [0],
+                    lengths: [snapshot.getLength()],
+                    data: plugins_1.allCodeFeatures,
+                }];
+        });
+    }
+    update(newSnapshot) {
+        this._snapshot(newSnapshot);
+    }
+}
+exports.VueVirtualCode = VueVirtualCode;
+//# sourceMappingURL=vueFile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.1.6",
+	"version": "3.1.8",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "341c06897f7f46606dddb8dd6d9e74e9c7844f02"
+	"gitHead": "0c9b66d0332698a1764fa56b64d47a6a30e81b47"
 }