@volar/language-core 2.2.0-alpha.8 → 2.2.0

package/index.d.ts

@@ -9,4 +9,3 @@ import type { CodeInformation, Language, LanguagePlugin, VirtualCode } from './l
 export declare function createLanguage(plugins: LanguagePlugin[], caseSensitive: boolean, sync: (id: string) => void): Language;
 export declare function updateVirtualCodeMapOfMap(virtualCode: VirtualCode, mapOfMap: Map<string, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>, getSourceSnapshot: (id: string | undefined) => [string, ts.IScriptSnapshot] | undefined): void;
 export declare function forEachEmbeddedCode(virtualCode: VirtualCode): Generator<VirtualCode>;
-export declare function resolveCommonLanguageId(fileNameOrUri: string): string;

package/index.js

@@ -14,7 +14,7 @@ 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 });
-exports.resolveCommonLanguageId = exports.forEachEmbeddedCode = exports.updateVirtualCodeMapOfMap = exports.createLanguage = void 0;
+exports.forEachEmbeddedCode = exports.updateVirtualCodeMapOfMap = exports.createLanguage = void 0;
 __exportStar(require("@volar/source-map"), exports);
 __exportStar(require("./lib/editorFeatures"), exports);
 __exportStar(require("./lib/linkedCodeMap"), exports);
@@ -35,26 +35,45 @@ function createLanguage(plugins, caseSensitive, sync) {
                 sync(id);
                 return sourceScripts.get(id);
             },
-            set(id, languageId, snapshot, _plugins = plugins) {
+            set(id, snapshot, languageId, _plugins = plugins) {
+                if (!languageId) {
+                    for (const plugin of plugins) {
+                        languageId = plugin.getLanguageId?.(id);
+                        if (languageId) {
+                            break;
+                        }
+                    }
+                }
+                if (!languageId) {
+                    console.warn(`languageId not found for ${id}`);
+                    return;
+                }
                 if (sourceScripts.has(id)) {
                     const sourceScript = sourceScripts.get(id);
                     if (sourceScript.languageId !== languageId) {
                         // languageId changed
                         this.delete(id);
-                        return this.set(id, languageId, snapshot);
+                        return this.set(id, snapshot, languageId);
                     }
                     else if (sourceScript.snapshot !== snapshot) {
                         // snapshot updated
                         sourceScript.snapshot = snapshot;
                         if (sourceScript.generated) {
-                            sourceScript.generated.root = sourceScript.generated.languagePlugin.updateVirtualCode(id, sourceScript.generated.root, snapshot);
-                            sourceScript.generated.embeddedCodes.clear();
-                            for (const code of forEachEmbeddedCode(sourceScript.generated.root)) {
-                                virtualCodeToSourceFileMap.set(code, sourceScript);
-                                sourceScript.generated.embeddedCodes.set(code.id, code);
+                            const newVirtualCode = sourceScript.generated.languagePlugin.updateVirtualCode?.(id, sourceScript.generated.root, snapshot);
+                            if (newVirtualCode) {
+                                sourceScript.generated.root = newVirtualCode;
+                                sourceScript.generated.embeddedCodes.clear();
+                                for (const code of forEachEmbeddedCode(sourceScript.generated.root)) {
+                                    virtualCodeToSourceFileMap.set(code, sourceScript);
+                                    sourceScript.generated.embeddedCodes.set(code.id, code);
+                                }
+                                return sourceScript;
+                            }
+                            else {
+                                this.delete(id);
+                                return;
                             }
                         }
-                        return sourceScript;
                     }
                     else {
                         // not changed
@@ -66,7 +85,7 @@ function createLanguage(plugins, caseSensitive, sync) {
                     const sourceScript = { id, languageId, snapshot };
                     sourceScripts.set(id, sourceScript);
                     for (const languagePlugin of _plugins) {
-                        const virtualCode = languagePlugin.createVirtualCode(id, languageId, snapshot);
+                        const virtualCode = languagePlugin.createVirtualCode?.(id, languageId, snapshot);
                         if (virtualCode) {
                             sourceScript.generated = {
                                 root: virtualCode,
@@ -172,21 +191,4 @@ function* forEachEmbeddedCode(virtualCode) {
     }
 }
 exports.forEachEmbeddedCode = forEachEmbeddedCode;
-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.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/types.d.ts

@@ -5,7 +5,7 @@ export interface Language {
     plugins: LanguagePlugin[];
     scripts: {
         get(id: string): SourceScript | undefined;
-        set(id: string, languageId: string, snapshot: ts.IScriptSnapshot, plugins?: LanguagePlugin[]): SourceScript;
+        set(id: string, snapshot: ts.IScriptSnapshot, languageId?: string, plugins?: LanguagePlugin[]): SourceScript | undefined;
         delete(id: string): void;
     };
     maps: {
@@ -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;
@@ -78,8 +78,9 @@ export interface ExtraServiceScript extends ServiceScript {
     fileName: string;
 }
 export interface LanguagePlugin<T extends VirtualCode = VirtualCode> {
-    createVirtualCode(scriptId: string, languageId: string, snapshot: ts.IScriptSnapshot): T | undefined;
-    updateVirtualCode(scriptId: string, virtualCode: T, newSnapshot: ts.IScriptSnapshot): T;
+    getLanguageId(scriptId: string): string | undefined;
+    createVirtualCode?(scriptId: string, languageId: string, snapshot: ts.IScriptSnapshot): T | undefined;
+    updateVirtualCode?(scriptId: string, virtualCode: T, newSnapshot: ts.IScriptSnapshot): T | undefined;
     disposeVirtualCode?(scriptId: string, virtualCode: T): void;
     typescript?: {
         /**
@@ -102,7 +103,6 @@ export interface LanguagePlugin<T extends VirtualCode = VirtualCode> {
 }
 export interface TypeScriptProjectHost extends ts.System, Pick<ts.LanguageServiceHost, 'getLocalizedDiagnosticMessages' | 'getCompilationSettings' | 'getProjectReferences' | 'getCurrentDirectory' | 'getScriptFileNames' | 'getProjectVersion' | 'getScriptSnapshot'> {
     configFileName: string | undefined;
-    getLanguageId(scriptId: string): string;
     getSystemVersion?(): number;
     syncSystem?(): Promise<number>;
     scriptIdToFileName(scriptId: string): string;

package/package.json

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

package/lib/fileRegistry.d.ts

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

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