@volar/language-core 2.2.0-alpha.0 → 2.2.0-alpha.10

package/index.js

@@ -142,6 +142,12 @@ function createLanguage(plugins, caseSensitive, sync) {
 exports.createLanguage = createLanguage;
 function updateVirtualCodeMapOfMap(virtualCode, mapOfMap, getSourceSnapshot) {
     const sources = new Set();
+    if (!virtualCode.mappings.length) {
+        const source = getSourceSnapshot(undefined);
+        if (source) {
+            mapOfMap.set(source[0], [source[1], new source_map_1.SourceMap([])]);
+        }
+    }
     for (const mapping of virtualCode.mappings) {
         if (sources.has(mapping.source)) {
             continue;

package/lib/editorFeatures.js

@@ -16,7 +16,7 @@ exports.isCodeLensEnabled = isCodeLensEnabled;
 function isSemanticTokensEnabled(info) {
     return typeof info.semantic === 'object'
         ? info.semantic.shouldHighlight?.() ?? true
-        : info.semantic;
+        : !!info.semantic;
 }
 exports.isSemanticTokensEnabled = isSemanticTokensEnabled;
 function isCallHierarchyEnabled(info) {
@@ -48,27 +48,27 @@ function isHighlightEnabled(info) {
 }
 exports.isHighlightEnabled = isHighlightEnabled;
 function isSymbolsEnabled(info) {
-    return info.structure;
+    return !!info.structure;
 }
 exports.isSymbolsEnabled = isSymbolsEnabled;
 function isFoldingRangesEnabled(info) {
-    return info.structure;
+    return !!info.structure;
 }
 exports.isFoldingRangesEnabled = isFoldingRangesEnabled;
 function isSelectionRangesEnabled(info) {
-    return info.structure;
+    return !!info.structure;
 }
 exports.isSelectionRangesEnabled = isSelectionRangesEnabled;
 function isLinkedEditingEnabled(info) {
-    return info.structure;
+    return !!info.structure;
 }
 exports.isLinkedEditingEnabled = isLinkedEditingEnabled;
 function isColorEnabled(info) {
-    return info.structure;
+    return !!info.structure;
 }
 exports.isColorEnabled = isColorEnabled;
 function isDocumentLinkEnabled(info) {
-    return info.structure;
+    return !!info.structure;
 }
 exports.isDocumentLinkEnabled = isDocumentLinkEnabled;
 function isDiagnosticsEnabled(info) {
@@ -80,7 +80,7 @@ function isCodeActionsEnabled(info) {
 }
 exports.isCodeActionsEnabled = isCodeActionsEnabled;
 function isFormattingEnabled(info) {
-    return info.format;
+    return !!info.format;
 }
 exports.isFormattingEnabled = isFormattingEnabled;
 function isCompletionEnabled(info) {
@@ -99,7 +99,7 @@ exports.isSignatureHelpEnabled = isSignatureHelpEnabled;
 function shouldReportDiagnostics(info) {
     return typeof info.verification === 'object'
         ? info.verification.shouldReport?.() ?? true
-        : info.verification;
+        : !!info.verification;
 }
 exports.shouldReportDiagnostics = shouldReportDiagnostics;
 //  resolve...

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>[];
+    set(id: string, languageId: string, snapshot: ts.IScriptSnapshot, plugins?: LanguagePlugin<VirtualCode>[]): 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, 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,137 @@
+"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, plugins = languagePlugins) {
+            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);
+                        for (const code of forEachEmbeddedCode(value.generated.code)) {
+                            virtualCodeToSourceFileMap.set(code, value);
+                        }
+                    }
+                    return value;
+                }
+                else {
+                    // not changed
+                    return value;
+                }
+            }
+            // created
+            const sourceFile = { id, languageId, snapshot };
+            sourceFiles.set(id, sourceFile);
+            for (const languagePlugin of plugins) {
+                const virtualCode = languagePlugin.createVirtualCode(id, languageId, snapshot, this);
+                if (virtualCode) {
+                    sourceFile.generated = {
+                        code: virtualCode,
+                        languagePlugin,
+                    };
+                    for (const code of forEachEmbeddedCode(virtualCode)) {
+                        virtualCodeToSourceFileMap.set(code, 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?.generated) {
+                for (const code of forEachEmbeddedCode(sourceFile.generated.code)) {
+                    if (code.id === virtualCodeId) {
+                        return [code, 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;
+    if (code.embeddedCodes) {
+        for (const embeddedCode of code.embeddedCodes) {
+            yield* forEachEmbeddedCode(embeddedCode);
+        }
+    }
+}
+exports.forEachEmbeddedCode = forEachEmbeddedCode;
+//# sourceMappingURL=fileRegistry.js.map

package/lib/types.d.ts

@@ -46,28 +46,28 @@ export interface VirtualCode {
 }
 export interface CodeInformation {
     /** virtual code is expected to support verification */
-    verification: boolean | {
+    verification?: boolean | {
         shouldReport?(): boolean;
     };
     /** virtual code is expected to support assisted completion */
-    completion: boolean | {
+    completion?: boolean | {
         isAdditional?: boolean;
         onlyImport?: boolean;
     };
     /** virtual code is expected correctly reflect semantic of the source code */
-    semantic: boolean | {
+    semantic?: boolean | {
         shouldHighlight?(): boolean;
     };
     /** virtual code is expected correctly reflect reference relationships of the source code */
-    navigation: boolean | {
+    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;
+    structure?: boolean;
     /** virtual code is expected correctly reflect the format information of the source code */
-    format: boolean;
+    format?: boolean;
 }
 export interface ServiceScript {
     code: VirtualCode;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/language-core",
-	"version": "2.2.0-alpha.0",
+	"version": "2.2.0-alpha.10",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/source-map": "2.2.0-alpha.0"
+		"@volar/source-map": "2.2.0-alpha.10"
 	},
-	"gitHead": "95ffe51f944ee87f570be113541e17ddfe75f588"
+	"gitHead": "aedd2230883c457f703be93ed150917a3efde75c"
 }