@volar/language-core 2.0.0-alpha.13 → 2.0.0-alpha.14

package/index.d.ts

@@ -1,5 +1,5 @@
 export * from './lib/editorFeatures';
-export * from './lib/fileProvider';
+export * from './lib/fileRegistry';
 export * from './lib/linkedCodeMap';
 export * from './lib/types';
 export * from './lib/utils';

package/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCommonLanguageId = void 0;
 __exportStar(require("./lib/editorFeatures"), exports);
-__exportStar(require("./lib/fileProvider"), exports);
+__exportStar(require("./lib/fileRegistry"), exports);
 __exportStar(require("./lib/linkedCodeMap"), exports);
 __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/utils"), exports);

package/lib/fileRegistry.d.ts

@@ -0,0 +1,17 @@
+import { SourceMap } from '@volar/source-map';
+import type * as ts from 'typescript';
+import { LinkedCodeMap } from './linkedCodeMap';
+import type { CodeInformation, LanguagePlugin, SourceFile, VirtualCode } from './types';
+export type FileRegistry = ReturnType<typeof createFileRegistry>;
+export declare function createFileRegistry(languagePlugins: LanguagePlugin[], caseSensitive: boolean, sync: (id: string) => void): {
+    languagePlugins: LanguagePlugin<VirtualCode<string>>[];
+    set(id: string, languageId: string, snapshot: ts.IScriptSnapshot): SourceFile;
+    delete(id: string): void;
+    get(id: string): SourceFile | undefined;
+    getByVirtualCode(virtualCode: VirtualCode): SourceFile;
+    getLinkedCodeMap(virtualCode: VirtualCode): LinkedCodeMap | undefined;
+    getMaps(virtualCode: VirtualCode): Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>;
+    getVirtualCode(sourceFileId: string, virtualCodeId: string): readonly [VirtualCode<string>, SourceFile] | readonly [undefined, undefined];
+};
+export declare function updateVirtualCodeMaps(virtualCode: VirtualCode, getSourceSnapshot: (sourceUri: string | undefined) => [string, ts.IScriptSnapshot] | undefined, map?: Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>): Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>;
+export declare function forEachEmbeddedCode(code: VirtualCode): Generator<VirtualCode>;

package/lib/fileRegistry.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachEmbeddedCode = exports.updateVirtualCodeMaps = exports.createFileRegistry = void 0;
+const source_map_1 = require("@volar/source-map");
+const linkedCodeMap_1 = require("./linkedCodeMap");
+const utils_1 = require("./utils");
+function createFileRegistry(languagePlugins, caseSensitive, sync) {
+    const sourceFiles = new utils_1.FileMap(caseSensitive);
+    const virtualCodeToSourceFileMap = new WeakMap();
+    const virtualCodeToMaps = new WeakMap();
+    const virtualCodeToLinkedCodeMap = new WeakMap();
+    return {
+        languagePlugins,
+        set(id, languageId, snapshot) {
+            const value = sourceFiles.get(id);
+            if (value) {
+                if (value.languageId !== languageId) {
+                    // languageId changed
+                    this.delete(id);
+                    return this.set(id, languageId, snapshot);
+                }
+                else if (value.snapshot !== snapshot) {
+                    // snapshot updated
+                    value.snapshot = snapshot;
+                    if (value.generated) {
+                        value.generated.code = value.generated.languagePlugin.updateVirtualCode(id, value.generated.code, snapshot, this);
+                        value.generated.idToFileMap.clear();
+                        for (const file of forEachEmbeddedCode(value.generated.code)) {
+                            value.generated.idToFileMap.set(file.id, file);
+                            virtualCodeToSourceFileMap.set(file, value);
+                        }
+                    }
+                    return value;
+                }
+                else {
+                    // not changed
+                    return value;
+                }
+            }
+            // created
+            const sourceFile = { id, languageId, snapshot };
+            sourceFiles.set(id, sourceFile);
+            for (const languagePlugin of languagePlugins) {
+                const virtualCode = languagePlugin.createVirtualCode(id, languageId, snapshot, this);
+                if (virtualCode) {
+                    sourceFile.generated = {
+                        code: virtualCode,
+                        languagePlugin,
+                        idToFileMap: new Map(),
+                    };
+                    for (const file of forEachEmbeddedCode(virtualCode)) {
+                        sourceFile.generated.idToFileMap.set(file.id, file);
+                        virtualCodeToSourceFileMap.set(file, sourceFile);
+                    }
+                    break;
+                }
+            }
+            return sourceFile;
+        },
+        delete(id) {
+            const value = sourceFiles.get(id);
+            if (value) {
+                if (value.generated) {
+                    value.generated.languagePlugin.disposeVirtualCode?.(id, value.generated.code, this);
+                }
+                sourceFiles.delete(id);
+            }
+        },
+        get(id) {
+            sync(id);
+            return sourceFiles.get(id);
+        },
+        getByVirtualCode(virtualCode) {
+            return virtualCodeToSourceFileMap.get(virtualCode);
+        },
+        getLinkedCodeMap(virtualCode) {
+            if (!virtualCodeToLinkedCodeMap.has(virtualCode.snapshot)) {
+                virtualCodeToLinkedCodeMap.set(virtualCode.snapshot, virtualCode.linkedCodeMappings
+                    ? new linkedCodeMap_1.LinkedCodeMap(virtualCode.linkedCodeMappings)
+                    : undefined);
+            }
+            return virtualCodeToLinkedCodeMap.get(virtualCode.snapshot);
+        },
+        getMaps(virtualCode) {
+            if (!virtualCodeToMaps.has(virtualCode.snapshot)) {
+                virtualCodeToMaps.set(virtualCode.snapshot, new Map());
+            }
+            updateVirtualCodeMaps(virtualCode, sourceFileId => {
+                if (sourceFileId) {
+                    const sourceFile = sourceFiles.get(sourceFileId);
+                    return [sourceFileId, sourceFile.snapshot];
+                }
+                else {
+                    const sourceFile = virtualCodeToSourceFileMap.get(virtualCode);
+                    return [sourceFile.id, sourceFile.snapshot];
+                }
+            }, virtualCodeToMaps.get(virtualCode.snapshot));
+            return virtualCodeToMaps.get(virtualCode.snapshot);
+        },
+        getVirtualCode(sourceFileId, virtualCodeId) {
+            const sourceFile = this.get(sourceFileId);
+            if (sourceFile) {
+                const virtualCode = sourceFile.generated?.idToFileMap.get(virtualCodeId);
+                if (virtualCode) {
+                    return [virtualCode, sourceFile];
+                }
+            }
+            return [undefined, undefined];
+        },
+    };
+}
+exports.createFileRegistry = createFileRegistry;
+function updateVirtualCodeMaps(virtualCode, getSourceSnapshot, map = new Map()) {
+    const sources = new Set();
+    for (const mapping of virtualCode.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(virtualCode.mappings.filter(mapping2 => mapping2.source === mapping.source))]);
+        }
+    }
+    return map;
+}
+exports.updateVirtualCodeMaps = updateVirtualCodeMaps;
+function* forEachEmbeddedCode(code) {
+    yield code;
+    for (const embeddedCode of code.embeddedCodes) {
+        yield* forEachEmbeddedCode(embeddedCode);
+    }
+}
+exports.forEachEmbeddedCode = forEachEmbeddedCode;
+//# sourceMappingURL=fileRegistry.js.map

package/lib/types.d.ts

@@ -1,16 +1,22 @@
 import type { Mapping, Stack } from '@volar/source-map';
 import type * as ts from 'typescript';
-import type { FileProvider } from './fileProvider';
-export interface SourceFile extends BaseFile {
-    virtualFile?: [VirtualFile, LanguagePlugin];
+import type { FileRegistry } from './fileRegistry';
+export interface SourceFile extends BaseCodeInfo {
+    /**
+     * uri or fileName
+     */
+    id: string;
+    generated?: {
+        code: VirtualCode;
+        languagePlugin: LanguagePlugin;
+        idToFileMap: Map<string, VirtualCode>;
+    };
 }
 export type CodeMapping = Mapping<CodeInformation>;
-export interface VirtualFile extends BaseFile {
+export interface VirtualCode<T extends string = string> extends BaseCodeInfo {
+    id: T;
     mappings: CodeMapping[];
-    embeddedFiles: VirtualFile[];
-    typescript?: {
-        scriptKind: ts.ScriptKind;
-    };
+    embeddedCodes: VirtualCode[];
     codegenStacks?: Stack[];
     linkedCodeMappings?: Mapping[];
 }
@@ -39,30 +45,33 @@ export interface CodeInformation {
     /** virtual code is expected correctly reflect the format information of the source code */
     format: boolean;
 }
-export interface BaseFile {
-    fileName: string;
+export interface BaseCodeInfo {
     languageId: string;
     snapshot: ts.IScriptSnapshot;
 }
-export interface LanguagePlugin<T extends VirtualFile = VirtualFile> {
-    createVirtualFile(id: string, languageId: string, snapshot: ts.IScriptSnapshot, files?: FileProvider): T | undefined;
-    updateVirtualFile(virtualFile: T, snapshot: ts.IScriptSnapshot, files?: FileProvider): void;
-    disposeVirtualFile?(virtualFile: T, files?: FileProvider): void;
+export interface LanguagePlugin<T extends VirtualCode = VirtualCode> {
+    createVirtualCode(fileId: string, languageId: string, snapshot: ts.IScriptSnapshot, files?: FileRegistry): T | undefined;
+    updateVirtualCode(fileId: string, virtualCode: T, newSnapshot: ts.IScriptSnapshot, files?: FileRegistry): T;
+    disposeVirtualCode?(fileId: string, virtualCode: T, files?: FileRegistry): void;
     typescript?: {
         extraFileExtensions: ts.FileExtensionInfo[];
-        resolveSourceFileName(tsFileName: string): string | undefined;
-        resolveModuleName?(path: string, impliedNodeFormat?: ts.ResolutionMode): string | undefined;
         resolveLanguageServiceHost?(host: ts.LanguageServiceHost): ts.LanguageServiceHost;
+        getScript(rootVirtualCode: T): {
+            code: VirtualCode;
+            extension: '.ts' | '.js' | '.mts' | '.mjs' | '.cjs' | '.cts' | '.d.ts' | string;
+            scriptKind: ts.ScriptKind;
+        } | undefined;
     };
 }
-export interface Language {
-    files: FileProvider;
+export interface LanguageContext {
+    files: FileRegistry;
     typescript?: {
         configFileName: string | undefined;
-        sys: ts.System;
+        sys: ts.System & {
+            sync?(): Promise<number>;
+        };
         projectHost: TypeScriptProjectHost;
         languageServiceHost: ts.LanguageServiceHost;
-        synchronizeFileSystem?(): Promise<number>;
     };
 }
 export interface TypeScriptProjectHost extends Pick<ts.LanguageServiceHost, 'getLocalizedDiagnosticMessages' | 'getCompilationSettings' | 'getProjectReferences' | 'getCurrentDirectory' | 'getScriptFileNames' | 'getProjectVersion' | 'getScriptSnapshot'> {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/language-core",
-	"version": "2.0.0-alpha.13",
+	"version": "2.0.0-alpha.14",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/source-map": "2.0.0-alpha.13"
+		"@volar/source-map": "2.0.0-alpha.14"
 	},
-	"gitHead": "b052e3d47235325ac614257be1cebd541d421134"
+	"gitHead": "83eb6a4a4475a3680f14fb3808e48ec4dbe62cc1"
 }

package/lib/fileProvider.d.ts

@@ -1,15 +0,0 @@
-import { SourceMap } from '@volar/source-map';
-import type * as ts from 'typescript';
-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: (sourceFileName: string) => void): {
-    updateSourceFile(fileName: string, languageId: string, snapshot: ts.IScriptSnapshot): SourceFile;
-    deleteSourceFile(fileName: string): void;
-    getLinkedCodeMap(file: VirtualFile): LinkedCodeMap | undefined;
-    getMaps(virtualFile: VirtualFile): Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>;
-    getSourceFile(fileName: string): SourceFile | undefined;
-    getVirtualFile(fileName: 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

@@ -1,142 +0,0 @@
-"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(fileName, languageId, snapshot) {
-            const value = sourceFileRegistry.get(fileName);
-            if (value) {
-                if (value.languageId !== languageId) {
-                    // languageId changed
-                    this.deleteSourceFile(fileName);
-                    return this.updateSourceFile(fileName, languageId, snapshot);
-                }
-                else if (value.snapshot !== snapshot) {
-                    // updated
-                    value.snapshot = snapshot;
-                    if (value.virtualFile) {
-                        disposeVirtualFiles(value);
-                        value.virtualFile[1].updateVirtualFile(value.virtualFile[0], snapshot, this);
-                        updateVirtualFiles(value);
-                    }
-                    return value;
-                }
-                else {
-                    // not changed
-                    return value;
-                }
-            }
-            for (const language of languages) {
-                const virtualFile = language.createVirtualFile(fileName, languageId, snapshot, this);
-                if (virtualFile) {
-                    // created
-                    const source = {
-                        fileName,
-                        languageId,
-                        snapshot,
-                        virtualFile: [virtualFile, language],
-                    };
-                    sourceFileRegistry.set(fileName, source);
-                    updateVirtualFiles(source);
-                    return source;
-                }
-            }
-            const source = { fileName, languageId, snapshot };
-            sourceFileRegistry.set(fileName, source);
-            return source;
-        },
-        deleteSourceFile(fileName) {
-            const value = sourceFileRegistry.get(fileName);
-            if (value) {
-                if (value.virtualFile) {
-                    value.virtualFile[1].disposeVirtualFile?.(value.virtualFile[0], this);
-                }
-                sourceFileRegistry.delete(fileName); // deleted
-                disposeVirtualFiles(value);
-            }
-        },
-        getLinkedCodeMap(file) {
-            if (!virtualFileToLinkedCodeMap.has(file.snapshot)) {
-                virtualFileToLinkedCodeMap.set(file.snapshot, file.linkedCodeMappings ? new linkedCodeMap_1.LinkedCodeMap(file.linkedCodeMappings) : 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.fileName)[1];
-                    return [sourceFile.fileName, sourceFile.snapshot];
-                }
-            }, virtualFileToMaps.get(virtualFile.snapshot));
-            return virtualFileToMaps.get(virtualFile.snapshot);
-        },
-        getSourceFile(fileName) {
-            sync(fileName);
-            return sourceFileRegistry.get(fileName);
-        },
-        getVirtualFile(fileName) {
-            let sourceAndVirtual = virtualFileRegistry.get(fileName);
-            if (sourceAndVirtual) {
-                sync(sourceAndVirtual[1].fileName);
-                sourceAndVirtual = virtualFileRegistry.get(fileName);
-                if (sourceAndVirtual) {
-                    return sourceAndVirtual;
-                }
-            }
-            return [undefined, undefined];
-        },
-    };
-    function disposeVirtualFiles(source) {
-        if (source.virtualFile) {
-            for (const file of forEachEmbeddedFile(source.virtualFile[0])) {
-                virtualFileRegistry.delete(file.fileName);
-            }
-        }
-    }
-    function updateVirtualFiles(source) {
-        if (source.virtualFile) {
-            for (const file of forEachEmbeddedFile(source.virtualFile[0])) {
-                virtualFileRegistry.set(file.fileName, [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