init

node_modules/@volar/language-core/lib/languageContext.d.ts

@@ -0,0 +1,9 @@
+import { createVirtualFiles } from './virtualFiles';
+import { Language, TypeScriptLanguageHost } from './types';
+export interface LanguageContext {
+    rawHost: TypeScriptLanguageHost;
+    host: TypeScriptLanguageHost;
+    virtualFiles: ReturnType<typeof createVirtualFiles>;
+}
+export declare function createLanguageContext(rawHost: TypeScriptLanguageHost, languages: Language<any>[]): LanguageContext;
+//# sourceMappingURL=languageContext.d.ts.map

node_modules/@volar/language-core/lib/languageContext.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageContext = void 0;
+const virtualFiles_1 = require("./virtualFiles");
+function createLanguageContext(rawHost, languages) {
+    let host = rawHost;
+    let lastRootFiles = new Map();
+    let lastProjectVersion;
+    const virtualFiles = (0, virtualFiles_1.createVirtualFiles)(languages);
+    for (const language of languages.reverse()) {
+        if (language.resolveHost) {
+            const pastHost = host;
+            let proxyHost = language.resolveHost(host);
+            if (proxyHost === pastHost) {
+                console.warn(`[volar] language.resolveHost() should not return the same host instance.`);
+                proxyHost = { ...proxyHost };
+            }
+            host = new Proxy(proxyHost, {
+                get(target, p) {
+                    if (p in target) {
+                        return target[p];
+                    }
+                    return pastHost[p];
+                }
+            });
+        }
+    }
+    return {
+        rawHost,
+        host,
+        virtualFiles: new Proxy(virtualFiles, {
+            get: (target, property) => {
+                syncVirtualFiles();
+                return target[property];
+            },
+        }),
+    };
+    function syncVirtualFiles() {
+        const newProjectVersion = host.getProjectVersion();
+        const shouldUpdate = newProjectVersion !== lastProjectVersion;
+        if (!shouldUpdate)
+            return;
+        const nowRootFiles = new Map();
+        const remainRootFiles = new Set(lastRootFiles.keys());
+        for (const rootFileName of host.getScriptFileNames()) {
+            nowRootFiles.set(rootFileName, host.getScriptSnapshot(rootFileName));
+        }
+        for (const [fileName, snapshot] of nowRootFiles) {
+            remainRootFiles.delete(fileName);
+            if (lastRootFiles.get(fileName) !== nowRootFiles.get(fileName)) {
+                if (snapshot) {
+                    virtualFiles.updateSource(fileName, snapshot, host.getLanguageId?.(fileName));
+                }
+                else {
+                    virtualFiles.deleteSource(fileName);
+                }
+            }
+        }
+        for (const fileName of remainRootFiles) {
+            virtualFiles.deleteSource(fileName);
+        }
+        lastRootFiles = nowRootFiles;
+        lastProjectVersion = newProjectVersion;
+    }
+}
+exports.createLanguageContext = createLanguageContext;
+//# sourceMappingURL=languageContext.js.map

node_modules/@volar/language-core/lib/sourceMaps.d.ts

@@ -0,0 +1,6 @@
+import * as SourceMaps from '@volar/source-map';
+import { MirrorBehaviorCapabilities } from './types';
+export declare class MirrorMap extends SourceMaps.SourceMap<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]> {
+    findMirrorOffsets(start: number): Generator<readonly [number, MirrorBehaviorCapabilities], void, unknown>;
+}
+//# sourceMappingURL=sourceMaps.d.ts.map

node_modules/@volar/language-core/lib/sourceMaps.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MirrorMap = void 0;
+const SourceMaps = require("@volar/source-map");
+class MirrorMap extends SourceMaps.SourceMap {
+    *findMirrorOffsets(start) {
+        for (const mapped of this.toGeneratedOffsets(start)) {
+            yield [mapped[0], mapped[1].data[1]];
+        }
+        for (const mapped of this.toSourceOffsets(start)) {
+            yield [mapped[0], mapped[1].data[0]];
+        }
+    }
+}
+exports.MirrorMap = MirrorMap;
+//# sourceMappingURL=sourceMaps.js.map

node_modules/@volar/language-core/lib/types.d.ts

@@ -0,0 +1,76 @@
+import { Mapping, Stack } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export interface FileCapabilities {
+    diagnostic?: boolean;
+    foldingRange?: boolean;
+    documentFormatting?: boolean;
+    documentSymbol?: boolean;
+    codeAction?: boolean;
+    inlayHint?: boolean;
+}
+export interface FileRangeCapabilities {
+    hover?: boolean;
+    references?: boolean;
+    definition?: boolean;
+    rename?: boolean | {
+        normalize?(newName: string): string;
+        apply?(newName: string): string;
+    };
+    completion?: boolean | {
+        additional?: boolean;
+        autoImportOnly?: boolean;
+    };
+    diagnostic?: boolean | {
+        shouldReport(): boolean;
+    };
+    semanticTokens?: boolean;
+    referencesCodeLens?: boolean;
+    displayWithLink?: boolean;
+}
+export interface MirrorBehaviorCapabilities {
+    references?: boolean;
+    definition?: boolean;
+    rename?: boolean;
+}
+export declare namespace FileCapabilities {
+    const full: FileCapabilities;
+}
+export declare namespace FileRangeCapabilities {
+    const full: FileRangeCapabilities;
+}
+export declare namespace MirrorBehaviorCapabilities {
+    const full: MirrorBehaviorCapabilities;
+}
+export declare enum FileKind {
+    TextFile = 0,
+    TypeScriptHostFile = 1
+}
+export interface VirtualFile {
+    fileName: string;
+    snapshot: ts.IScriptSnapshot;
+    kind: FileKind;
+    capabilities: FileCapabilities;
+    mappings: Mapping<FileRangeCapabilities>[];
+    codegenStacks: Stack[];
+    mirrorBehaviorMappings?: Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
+    embeddedFiles: VirtualFile[];
+}
+export interface Language<T extends VirtualFile = VirtualFile> {
+    resolveHost?(host: TypeScriptLanguageHost): TypeScriptLanguageHost;
+    createVirtualFile(fileName: string, snapshot: ts.IScriptSnapshot, languageId: string | undefined): T | undefined;
+    updateVirtualFile(virtualFile: T, snapshot: ts.IScriptSnapshot): void;
+    deleteVirtualFile?(virtualFile: T): void;
+}
+interface LanguageHost {
+    workspacePath: string;
+    rootPath: string;
+    getProjectVersion(): string;
+    getScriptFileNames(): string[];
+    getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined;
+    getLanguageId?(fileName: string): string | undefined;
+}
+export interface TypeScriptLanguageHost extends LanguageHost, Pick<ts.LanguageServiceHost, 'getCancellationToken' | 'getLocalizedDiagnosticMessages' | 'getCompilationSettings' | 'getProjectReferences'> {
+    resolveModuleName?(path: string, impliedNodeFormat?: ts.ResolutionMode): string;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

node_modules/@volar/language-core/lib/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileKind = exports.MirrorBehaviorCapabilities = exports.FileRangeCapabilities = exports.FileCapabilities = void 0;
+var FileCapabilities;
+(function (FileCapabilities) {
+    FileCapabilities.full = {
+        diagnostic: true,
+        foldingRange: true,
+        documentFormatting: true,
+        documentSymbol: true,
+        codeAction: true,
+        inlayHint: true,
+    };
+})(FileCapabilities || (exports.FileCapabilities = FileCapabilities = {}));
+var FileRangeCapabilities;
+(function (FileRangeCapabilities) {
+    FileRangeCapabilities.full = {
+        hover: true,
+        references: true,
+        definition: true,
+        rename: true,
+        completion: true,
+        diagnostic: true,
+        semanticTokens: true,
+    };
+})(FileRangeCapabilities || (exports.FileRangeCapabilities = FileRangeCapabilities = {}));
+var MirrorBehaviorCapabilities;
+(function (MirrorBehaviorCapabilities) {
+    MirrorBehaviorCapabilities.full = {
+        references: true,
+        definition: true,
+        rename: true,
+    };
+})(MirrorBehaviorCapabilities || (exports.MirrorBehaviorCapabilities = MirrorBehaviorCapabilities = {}));
+var FileKind;
+(function (FileKind) {
+    FileKind[FileKind["TextFile"] = 0] = "TextFile";
+    FileKind[FileKind["TypeScriptHostFile"] = 1] = "TypeScriptHostFile";
+})(FileKind || (exports.FileKind = FileKind = {}));
+//# sourceMappingURL=types.js.map

node_modules/@volar/language-core/lib/virtualFiles.d.ts

@@ -0,0 +1,26 @@
+import { SourceMap } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { MirrorMap } from './sourceMaps';
+import type { FileRangeCapabilities, Language, VirtualFile } from './types';
+export type VirtualFiles = ReturnType<typeof createVirtualFiles>;
+export interface Source {
+    fileName: string;
+    languageId: string | undefined;
+    snapshot: ts.IScriptSnapshot;
+    root: VirtualFile;
+    language: Language;
+}
+export declare function createVirtualFiles(languages: Language[]): {
+    allSources(): Source[];
+    updateSource(fileName: string, snapshot: ts.IScriptSnapshot, languageId: string | undefined): VirtualFile | undefined;
+    deleteSource(fileName: string): void;
+    getSource(fileName: string): Source | undefined;
+    hasSource: (fileName: string) => boolean;
+    getMirrorMap: (file: VirtualFile) => MirrorMap | undefined;
+    getMaps: (virtualFile: VirtualFile) => Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>;
+    hasVirtualFile(fileName: string): boolean;
+    getVirtualFile(fileName: string): readonly [VirtualFile, Source] | readonly [undefined, undefined];
+};
+export declare function updateVirtualFileMaps(virtualFile: VirtualFile, getSourceSnapshot: (source: string | undefined) => [string, ts.IScriptSnapshot] | undefined, map?: Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>): Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>;
+export declare function forEachEmbeddedFile(file: VirtualFile, cb: (embedded: VirtualFile) => void): void;
+//# sourceMappingURL=virtualFiles.d.ts.map

node_modules/@volar/language-core/lib/virtualFiles.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachEmbeddedFile = exports.updateVirtualFileMaps = exports.createVirtualFiles = void 0;
+const source_map_1 = require("@volar/source-map");
+const sourceMaps_1 = require("./sourceMaps");
+function createVirtualFiles(languages) {
+    const sourceFiles = new Map();
+    const virtualFiles = new Map();
+    const virtualFileMaps = new WeakMap();
+    const virtualFileToMirrorMap = new WeakMap();
+    return {
+        allSources() {
+            return Array.from(sourceFiles.values());
+        },
+        updateSource(fileName, snapshot, languageId) {
+            const key = normalizePath(fileName);
+            const value = sourceFiles.get(key);
+            if (value) {
+                if (value.languageId !== languageId) {
+                    // languageId changed
+                    this.deleteSource(fileName);
+                    return this.updateSource(fileName, snapshot, languageId);
+                }
+                else {
+                    value.snapshot = snapshot;
+                    deleteVirtualFiles(value);
+                    value.language.updateVirtualFile(value.root, snapshot);
+                    updateVirtualFiles(value);
+                    return value.root; // updated
+                }
+            }
+            for (const language of languages) {
+                const virtualFile = language.createVirtualFile(fileName, snapshot, languageId);
+                if (virtualFile) {
+                    const source = { fileName, languageId, snapshot, root: virtualFile, language };
+                    sourceFiles.set(key, source);
+                    updateVirtualFiles(source);
+                    return virtualFile; // created
+                }
+            }
+        },
+        deleteSource(fileName) {
+            const key = normalizePath(fileName);
+            const value = sourceFiles.get(key);
+            if (value) {
+                value.language.deleteVirtualFile?.(value.root);
+                sourceFiles.delete(key); // deleted
+                deleteVirtualFiles(value);
+            }
+        },
+        getSource(fileName) {
+            const key = normalizePath(fileName);
+            return sourceFiles.get(key);
+        },
+        hasSource: (fileName) => sourceFiles.has(normalizePath(fileName)),
+        getMirrorMap: getMirrorMap,
+        getMaps: getMapsByVirtualFile,
+        hasVirtualFile(fileName) {
+            return !!virtualFiles.get(normalizePath(fileName));
+        },
+        getVirtualFile(fileName) {
+            const sourceAndVirtual = virtualFiles.get(normalizePath(fileName));
+            if (sourceAndVirtual) {
+                return [sourceAndVirtual.virtualFile, sourceAndVirtual.source];
+            }
+            return [undefined, undefined];
+        },
+    };
+    function deleteVirtualFiles(source) {
+        forEachEmbeddedFile(source.root, file => {
+            virtualFiles.delete(normalizePath(file.fileName));
+        });
+    }
+    function updateVirtualFiles(source) {
+        forEachEmbeddedFile(source.root, file => {
+            virtualFiles.set(normalizePath(file.fileName), { virtualFile: file, source });
+        });
+    }
+    function getMapsByVirtualFile(virtualFile) {
+        if (!virtualFileMaps.has(virtualFile.snapshot)) {
+            virtualFileMaps.set(virtualFile.snapshot, new Map());
+        }
+        updateVirtualFileMaps(virtualFile, sourceFileName => {
+            if (sourceFileName) {
+                const source = sourceFiles.get(normalizePath(sourceFileName));
+                return [sourceFileName, source.snapshot];
+            }
+            else {
+                const source = virtualFiles.get(normalizePath(virtualFile.fileName)).source;
+                return [source.fileName, source.snapshot];
+            }
+        }, virtualFileMaps.get(virtualFile.snapshot));
+        return virtualFileMaps.get(virtualFile.snapshot);
+    }
+    function getMirrorMap(file) {
+        if (!virtualFileToMirrorMap.has(file.snapshot)) {
+            virtualFileToMirrorMap.set(file.snapshot, file.mirrorBehaviorMappings ? new sourceMaps_1.MirrorMap(file.mirrorBehaviorMappings) : undefined);
+        }
+        return virtualFileToMirrorMap.get(file.snapshot);
+    }
+}
+exports.createVirtualFiles = createVirtualFiles;
+function updateVirtualFileMaps(virtualFile, getSourceSnapshot, map = new Map()) {
+    const sources = new Set();
+    for (const mapping of virtualFile.mappings) {
+        if (sources.has(mapping.source))
+            continue;
+        sources.add(mapping.source);
+        const source = getSourceSnapshot(mapping.source);
+        if (!source)
+            continue;
+        if (!map.has(source[0]) || map.get(source[0])[0] !== source[1]) {
+            map.set(source[0], [source[1], new source_map_1.SourceMap(virtualFile.mappings.filter(mapping2 => mapping2.source === mapping.source))]);
+        }
+    }
+    return map;
+}
+exports.updateVirtualFileMaps = updateVirtualFileMaps;
+function forEachEmbeddedFile(file, cb) {
+    cb(file);
+    for (const embeddedFile of file.embeddedFiles) {
+        forEachEmbeddedFile(embeddedFile, cb);
+    }
+}
+exports.forEachEmbeddedFile = forEachEmbeddedFile;
+function normalizePath(fileName) {
+    return fileName.replace(/\\/g, '/').toLowerCase();
+}
+//# sourceMappingURL=virtualFiles.js.map