@volar/language-core 1.11.0 → 2.0.0-alpha.0

package/index.d.ts

@@ -1,5 +1,7 @@
-export * from './lib/virtualFiles';
-export * from './lib/languageContext';
-export * from './lib/sourceMaps';
+export * from './lib/editorFeatures';
+export * from './lib/fileProvider';
+export * from './lib/linkedCodeMap';
 export * from './lib/types';
-//# sourceMappingURL=index.d.ts.map
+export * from './lib/utils';
+export * from '@volar/source-map';
+export declare function resolveCommonLanguageId(fileNameOrUri: string): string;

package/index.js

@@ -14,8 +14,28 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/virtualFiles"), exports);
-__exportStar(require("./lib/languageContext"), exports);
-__exportStar(require("./lib/sourceMaps"), exports);
+exports.resolveCommonLanguageId = void 0;
+__exportStar(require("./lib/editorFeatures"), exports);
+__exportStar(require("./lib/fileProvider"), exports);
+__exportStar(require("./lib/linkedCodeMap"), exports);
 __exportStar(require("./lib/types"), exports);
+__exportStar(require("./lib/utils"), exports);
+__exportStar(require("@volar/source-map"), exports);
+function resolveCommonLanguageId(fileNameOrUri) {
+    const ext = fileNameOrUri.split('.').pop();
+    switch (ext) {
+        case 'js': return 'javascript';
+        case 'cjs': return 'javascript';
+        case 'mjs': return 'javascript';
+        case 'ts': return 'typescript';
+        case 'cts': return 'typescript';
+        case 'mts': return 'typescript';
+        case 'jsx': return 'javascriptreact';
+        case 'tsx': return 'typescriptreact';
+        case 'pug': return 'jade';
+        case 'md': return 'markdown';
+    }
+    return ext;
+}
+exports.resolveCommonLanguageId = resolveCommonLanguageId;
 //# sourceMappingURL=index.js.map

package/lib/editorFeatures.d.ts

@@ -0,0 +1,27 @@
+import type { CodeInformation } from './types';
+export declare function isHoverEnabled(info: CodeInformation): boolean;
+export declare function isInlayHintsEnabled(info: CodeInformation): boolean;
+export declare function isCodeLensEnabled(info: CodeInformation): boolean;
+export declare function isSemanticTokensEnabled(info: CodeInformation): boolean;
+export declare function isCallHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isRenameEnabled(info: CodeInformation): boolean;
+export declare function isDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isTypeDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isReferencesEnabled(info: CodeInformation): boolean;
+export declare function isImplementationEnabled(info: CodeInformation): boolean;
+export declare function isHighlightEnabled(info: CodeInformation): boolean;
+export declare function isSymbolsEnabled(info: CodeInformation): boolean;
+export declare function isFoldingRangesEnabled(info: CodeInformation): boolean;
+export declare function isSelectionRangesEnabled(info: CodeInformation): boolean;
+export declare function isLinkedEditingEnabled(info: CodeInformation): boolean;
+export declare function isColorEnabled(info: CodeInformation): boolean;
+export declare function isDocumentLinkEnabled(info: CodeInformation): boolean;
+export declare function isDiagnosticsEnabled(info: CodeInformation): boolean;
+export declare function isCodeActionsEnabled(info: CodeInformation): boolean;
+export declare function isFormattingEnabled(info: CodeInformation): boolean;
+export declare function isCompletionEnabled(info: CodeInformation): boolean;
+export declare function isAutoInsertEnabled(info: CodeInformation): boolean;
+export declare function isSignatureHelpEnabled(info: CodeInformation): boolean;
+export declare function shouldReportDiagnostics(info: CodeInformation): boolean;
+export declare function resolveRenameNewName(newName: string, info: CodeInformation): string;
+export declare function resolveRenameEditText(text: string, info: CodeInformation): string;

package/lib/editorFeatures.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRenameEditText = exports.resolveRenameNewName = exports.shouldReportDiagnostics = exports.isSignatureHelpEnabled = exports.isAutoInsertEnabled = exports.isCompletionEnabled = exports.isFormattingEnabled = exports.isCodeActionsEnabled = exports.isDiagnosticsEnabled = exports.isDocumentLinkEnabled = exports.isColorEnabled = exports.isLinkedEditingEnabled = exports.isSelectionRangesEnabled = exports.isFoldingRangesEnabled = exports.isSymbolsEnabled = exports.isHighlightEnabled = exports.isImplementationEnabled = exports.isReferencesEnabled = exports.isTypeDefinitionEnabled = exports.isDefinitionEnabled = exports.isRenameEnabled = exports.isCallHierarchyEnabled = exports.isSemanticTokensEnabled = exports.isCodeLensEnabled = exports.isInlayHintsEnabled = exports.isHoverEnabled = void 0;
+function isHoverEnabled(info) {
+    return !!info.semantic;
+}
+exports.isHoverEnabled = isHoverEnabled;
+function isInlayHintsEnabled(info) {
+    return !!info.semantic;
+}
+exports.isInlayHintsEnabled = isInlayHintsEnabled;
+function isCodeLensEnabled(info) {
+    return !!info.semantic;
+}
+exports.isCodeLensEnabled = isCodeLensEnabled;
+function isSemanticTokensEnabled(info) {
+    return typeof info.semantic === 'object'
+        ? info.semantic.shouldHighlight?.() ?? true
+        : info.semantic;
+}
+exports.isSemanticTokensEnabled = isSemanticTokensEnabled;
+function isCallHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+exports.isCallHierarchyEnabled = isCallHierarchyEnabled;
+function isRenameEnabled(info) {
+    return !!info.navigation;
+}
+exports.isRenameEnabled = isRenameEnabled;
+function isDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+exports.isDefinitionEnabled = isDefinitionEnabled;
+function isTypeDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+exports.isTypeDefinitionEnabled = isTypeDefinitionEnabled;
+function isReferencesEnabled(info) {
+    return !!info.navigation;
+}
+exports.isReferencesEnabled = isReferencesEnabled;
+function isImplementationEnabled(info) {
+    return !!info.navigation;
+}
+exports.isImplementationEnabled = isImplementationEnabled;
+function isHighlightEnabled(info) {
+    return !!info.navigation;
+}
+exports.isHighlightEnabled = isHighlightEnabled;
+function isSymbolsEnabled(info) {
+    return info.structure;
+}
+exports.isSymbolsEnabled = isSymbolsEnabled;
+function isFoldingRangesEnabled(info) {
+    return info.structure;
+}
+exports.isFoldingRangesEnabled = isFoldingRangesEnabled;
+function isSelectionRangesEnabled(info) {
+    return info.structure;
+}
+exports.isSelectionRangesEnabled = isSelectionRangesEnabled;
+function isLinkedEditingEnabled(info) {
+    return info.structure;
+}
+exports.isLinkedEditingEnabled = isLinkedEditingEnabled;
+function isColorEnabled(info) {
+    return info.structure;
+}
+exports.isColorEnabled = isColorEnabled;
+function isDocumentLinkEnabled(info) {
+    return info.structure;
+}
+exports.isDocumentLinkEnabled = isDocumentLinkEnabled;
+function isDiagnosticsEnabled(info) {
+    return !!info.verification;
+}
+exports.isDiagnosticsEnabled = isDiagnosticsEnabled;
+function isCodeActionsEnabled(info) {
+    return !!info.verification;
+}
+exports.isCodeActionsEnabled = isCodeActionsEnabled;
+function isFormattingEnabled(info) {
+    return info.format;
+}
+exports.isFormattingEnabled = isFormattingEnabled;
+function isCompletionEnabled(info) {
+    return !!info.completion;
+}
+exports.isCompletionEnabled = isCompletionEnabled;
+function isAutoInsertEnabled(info) {
+    return !!info.completion;
+}
+exports.isAutoInsertEnabled = isAutoInsertEnabled;
+function isSignatureHelpEnabled(info) {
+    return !!info.completion;
+}
+exports.isSignatureHelpEnabled = isSignatureHelpEnabled;
+// should...
+function shouldReportDiagnostics(info) {
+    return typeof info.verification === 'object'
+        ? info.verification.shouldReport?.() ?? true
+        : info.verification;
+}
+exports.shouldReportDiagnostics = shouldReportDiagnostics;
+//  resolve...
+function resolveRenameNewName(newName, info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.resolveRenameNewName?.(newName) ?? newName
+        : newName;
+}
+exports.resolveRenameNewName = resolveRenameNewName;
+function resolveRenameEditText(text, info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.resolveRenameEditText?.(text) ?? text
+        : text;
+}
+exports.resolveRenameEditText = resolveRenameEditText;
+//# sourceMappingURL=editorFeatures.js.map

package/lib/fileProvider.d.ts

@@ -0,0 +1,15 @@
+import { SourceMap } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { LinkedCodeMap } from './linkedCodeMap';
+import type { CodeInformation, LanguagePlugin, SourceFile, VirtualFile } from './types';
+export type FileProvider = ReturnType<typeof createFileProvider>;
+export declare function createFileProvider(languages: LanguagePlugin[], caseSensitive: boolean, sync: (sourceFileId: string) => void): {
+    updateSourceFile(id: string, snapshot: ts.IScriptSnapshot, languageId: string): SourceFile;
+    deleteSourceFile(id: string): void;
+    getLinkedCodeMap(file: VirtualFile): LinkedCodeMap | undefined;
+    getMaps(virtualFile: VirtualFile): Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>;
+    getSourceFile(id: string): SourceFile | undefined;
+    getVirtualFile(id: string): [VirtualFile, SourceFile] | readonly [undefined, undefined];
+};
+export declare function updateVirtualFileMaps(virtualFile: VirtualFile, getSourceSnapshot: (sourceUri: string | undefined) => [string, ts.IScriptSnapshot] | undefined, map?: Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>): Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>;
+export declare function forEachEmbeddedFile(file: VirtualFile): Generator<VirtualFile>;

package/lib/fileProvider.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachEmbeddedFile = exports.updateVirtualFileMaps = exports.createFileProvider = void 0;
+const source_map_1 = require("@volar/source-map");
+const linkedCodeMap_1 = require("./linkedCodeMap");
+const utils_1 = require("./utils");
+function createFileProvider(languages, caseSensitive, sync) {
+    const sourceFileRegistry = new utils_1.FileMap(caseSensitive);
+    const virtualFileRegistry = new utils_1.FileMap(caseSensitive);
+    const virtualFileToMaps = new WeakMap();
+    const virtualFileToLinkedCodeMap = new WeakMap();
+    return {
+        updateSourceFile(id, snapshot, languageId) {
+            const value = sourceFileRegistry.get(id);
+            if (value) {
+                if (value.languageId !== languageId) {
+                    // languageId changed
+                    this.deleteSourceFile(id);
+                    return this.updateSourceFile(id, snapshot, languageId);
+                }
+                else if (value.snapshot !== snapshot) {
+                    // updated
+                    value.snapshot = snapshot;
+                    if (value.virtualFile) {
+                        disposeVirtualFiles(value);
+                        value.virtualFile[1].updateVirtualFile(value.virtualFile[0], snapshot);
+                        updateVirtualFiles(value);
+                    }
+                    return value;
+                }
+                else {
+                    // not changed
+                    return value;
+                }
+            }
+            for (const language of languages) {
+                const virtualFile = language.createVirtualFile(id, languageId, snapshot);
+                if (virtualFile) {
+                    // created
+                    const source = {
+                        id,
+                        languageId,
+                        snapshot,
+                        virtualFile: [virtualFile, language],
+                    };
+                    sourceFileRegistry.set(id, source);
+                    updateVirtualFiles(source);
+                    return source;
+                }
+            }
+            const source = { id: id, languageId, snapshot };
+            sourceFileRegistry.set(id, source);
+            return source;
+        },
+        deleteSourceFile(id) {
+            const value = sourceFileRegistry.get(id);
+            if (value) {
+                if (value.virtualFile) {
+                    value.virtualFile[1].disposeVirtualFile?.(value.virtualFile[0]);
+                }
+                sourceFileRegistry.delete(id); // deleted
+                disposeVirtualFiles(value);
+            }
+        },
+        getLinkedCodeMap(file) {
+            if (!virtualFileToLinkedCodeMap.has(file.snapshot)) {
+                virtualFileToLinkedCodeMap.set(file.snapshot, file.linkedNavigationMappings ? new linkedCodeMap_1.LinkedCodeMap(file.linkedNavigationMappings) : undefined);
+            }
+            return virtualFileToLinkedCodeMap.get(file.snapshot);
+        },
+        getMaps(virtualFile) {
+            if (!virtualFileToMaps.has(virtualFile.snapshot)) {
+                virtualFileToMaps.set(virtualFile.snapshot, new Map());
+            }
+            updateVirtualFileMaps(virtualFile, sourceId => {
+                if (sourceId) {
+                    const sourceFile = sourceFileRegistry.get(sourceId);
+                    return [sourceId, sourceFile.snapshot];
+                }
+                else {
+                    const sourceFile = virtualFileRegistry.get(virtualFile.id)[1];
+                    return [sourceFile.id, sourceFile.snapshot];
+                }
+            }, virtualFileToMaps.get(virtualFile.snapshot));
+            return virtualFileToMaps.get(virtualFile.snapshot);
+        },
+        getSourceFile(id) {
+            sync(id);
+            return sourceFileRegistry.get(id);
+        },
+        getVirtualFile(id) {
+            let sourceAndVirtual = virtualFileRegistry.get(id);
+            if (sourceAndVirtual) {
+                sync(sourceAndVirtual[1].id);
+                sourceAndVirtual = virtualFileRegistry.get(id);
+                if (sourceAndVirtual) {
+                    return sourceAndVirtual;
+                }
+            }
+            return [undefined, undefined];
+        },
+    };
+    function disposeVirtualFiles(source) {
+        if (source.virtualFile) {
+            for (const file of forEachEmbeddedFile(source.virtualFile[0])) {
+                virtualFileRegistry.delete(file.id);
+            }
+        }
+    }
+    function updateVirtualFiles(source) {
+        if (source.virtualFile) {
+            for (const file of forEachEmbeddedFile(source.virtualFile[0])) {
+                virtualFileRegistry.set(file.id, [file, source]);
+            }
+        }
+    }
+}
+exports.createFileProvider = createFileProvider;
+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) {
+    yield file;
+    for (const embeddedFile of file.embeddedFiles) {
+        yield* forEachEmbeddedFile(embeddedFile);
+    }
+}
+exports.forEachEmbeddedFile = forEachEmbeddedFile;
+//# sourceMappingURL=fileProvider.js.map

package/lib/linkedCodeMap.d.ts

@@ -0,0 +1,4 @@
+import { SourceMap } from '@volar/source-map';
+export declare class LinkedCodeMap extends SourceMap {
+    getLinkedOffsets(start: number): Generator<number, void, unknown>;
+}

package/lib/linkedCodeMap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedCodeMap = void 0;
+const source_map_1 = require("@volar/source-map");
+class LinkedCodeMap extends source_map_1.SourceMap {
+    *getLinkedOffsets(start) {
+        for (const mapped of this.getGeneratedOffsets(start)) {
+            yield mapped[0];
+        }
+        for (const mapped of this.getSourceOffsets(start)) {
+            yield mapped[0];
+        }
+    }
+}
+exports.LinkedCodeMap = LinkedCodeMap;
+//# sourceMappingURL=linkedCodeMap.js.map

package/lib/types.d.ts

@@ -1,76 +1,75 @@
-import { Mapping, Stack } from '@volar/source-map';
+import type { 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;
+import type { FileProvider } from './fileProvider';
+export interface SourceFile extends BaseFile {
+    virtualFile?: [VirtualFile, LanguagePlugin];
 }
-export interface FileRangeCapabilities {
-    hover?: boolean;
-    references?: boolean;
-    definition?: boolean;
-    rename?: boolean | {
-        normalize?(newName: string): string;
-        apply?(newName: string): string;
+export interface VirtualFile extends BaseFile {
+    mappings: Mapping<CodeInformation>[];
+    embeddedFiles: VirtualFile[];
+    typescript?: {
+        scriptKind: ts.ScriptKind;
     };
-    completion?: boolean | {
-        additional?: boolean;
-        autoImportOnly?: boolean;
+    codegenStacks?: Stack[];
+    linkedNavigationMappings?: Mapping[];
+}
+export interface CodeInformation {
+    /** virtual code is expected to support verification */
+    verification: boolean | {
+        shouldReport?(): boolean;
     };
-    diagnostic?: boolean | {
-        shouldReport(): boolean;
+    /** virtual code is expected to support assisted completion */
+    completion: boolean | {
+        isAdditional?: boolean;
+        onlyImport?: 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
+    /** virtual code is expected correctly reflect semantic of the source code */
+    semantic: boolean | {
+        shouldHighlight?(): boolean;
+    };
+    /** virtual code is expected correctly reflect reference relationships of the source code */
+    navigation: boolean | {
+        shouldRename?(): boolean;
+        resolveRenameNewName?(newName: string): string;
+        resolveRenameEditText?(newText: string): string;
+    };
+    /** virtual code is expected correctly reflect the structural information of the source code */
+    structure: boolean;
+    /** virtual code is expected correctly reflect the format information of the source code */
+    format: boolean;
 }
-export interface VirtualFile {
-    fileName: string;
+export interface BaseFile {
+    /**
+     * for language-server, kit, monaco, this is uri
+     *
+     * for typescript server plugin, tsc, this is fileName
+     */
+    id: string;
+    languageId: 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;
+export interface LanguagePlugin<T extends VirtualFile = VirtualFile> {
+    createVirtualFile(id: string, languageId: string, snapshot: ts.IScriptSnapshot): T | undefined;
     updateVirtualFile(virtualFile: T, snapshot: ts.IScriptSnapshot): void;
-    deleteVirtualFile?(virtualFile: T): void;
+    disposeVirtualFile?(virtualFile: T): void;
+    typescript?: {
+        resolveSourceFileName(tsFileName: string): string | undefined;
+        resolveModuleName?(path: string, impliedNodeFormat?: ts.ResolutionMode): string | undefined;
+        resolveLanguageServiceHost?(host: ts.LanguageServiceHost): ts.LanguageServiceHost;
+    };
 }
-interface LanguageHost {
-    workspacePath: string;
-    rootPath: string;
-    getProjectVersion(): string;
-    getScriptFileNames(): string[];
-    getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined;
-    getLanguageId?(fileName: string): string | undefined;
+export interface Language {
+    files: FileProvider;
+    typescript?: {
+        configFileName: string | undefined;
+        sys: ts.System;
+        projectHost: TypeScriptProjectHost;
+        languageServiceHost: ts.LanguageServiceHost;
+        synchronizeFileSystem?(): Promise<number>;
+    };
 }
-export interface TypeScriptLanguageHost extends LanguageHost, Pick<ts.LanguageServiceHost, 'getCancellationToken' | 'getLocalizedDiagnosticMessages' | 'getCompilationSettings' | 'getProjectReferences'> {
-    resolveModuleName?(path: string, impliedNodeFormat?: ts.ResolutionMode): string;
+export interface TypeScriptProjectHost extends Pick<ts.LanguageServiceHost, 'getLocalizedDiagnosticMessages' | 'getCompilationSettings' | 'getProjectReferences' | 'getCurrentDirectory' | 'getScriptFileNames' | 'getProjectVersion' | 'getScriptSnapshot' | 'getCancellationToken'> {
+    getFileId(fileName: string): string;
+    getFileName(fileId: string): string;
+    getLanguageId(id: string): string;
 }
-export {};
-//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -1,40 +1,3 @@
 "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

package/lib/utils.d.ts

@@ -0,0 +1,12 @@
+export declare class FileMap<T> extends Map<string, T> {
+    private caseSensitive;
+    private originalFileNames;
+    constructor(caseSensitive: boolean);
+    keys(): IterableIterator<string>;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    set(key: string, value: T): this;
+    delete(key: string): boolean;
+    clear(): void;
+    normalizeId(id: string): string;
+}

package/lib/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMap = void 0;
+class FileMap extends Map {
+    constructor(caseSensitive) {
+        super();
+        this.caseSensitive = caseSensitive;
+        this.originalFileNames = new Map();
+    }
+    keys() {
+        return this.originalFileNames.values();
+    }
+    get(key) {
+        return super.get(this.normalizeId(key));
+    }
+    has(key) {
+        return super.has(this.normalizeId(key));
+    }
+    set(key, value) {
+        this.originalFileNames.set(this.normalizeId(key), key);
+        return super.set(this.normalizeId(key), value);
+    }
+    delete(key) {
+        this.originalFileNames.delete(this.normalizeId(key));
+        return super.delete(this.normalizeId(key));
+    }
+    clear() {
+        this.originalFileNames.clear();
+        return super.clear();
+    }
+    normalizeId(id) {
+        return this.caseSensitive ? id : id.toLowerCase();
+    }
+}
+exports.FileMap = FileMap;
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/language-core",
-	"version": "1.11.0",
+	"version": "2.0.0-alpha.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/source-map": "1.11.0"
+		"@volar/source-map": "2.0.0-alpha.0"
 	},
-	"gitHead": "e3f563cbbf4cc03c058f5df38df0498034e5feb5"
+	"gitHead": "6a6be45a3b7983148d90541e7c68ef84c9155a7a"
 }

package/lib/languageContext.d.ts

@@ -1,9 +0,0 @@
-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

package/lib/languageContext.js

@@ -1,67 +0,0 @@
-"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

package/lib/sourceMaps.d.ts

@@ -1,6 +0,0 @@
-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

package/lib/sourceMaps.js

@@ -1,16 +0,0 @@
-"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

package/lib/virtualFiles.d.ts

@@ -1,26 +0,0 @@
-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

package/lib/virtualFiles.js

@@ -1,129 +0,0 @@
-"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