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

package/index.d.ts

@@ -3,9 +3,6 @@ export * from './lib/editorFeatures';
 export * from './lib/linkedCodeMap';
 export * from './lib/types';
 export * from './lib/utils';
-import { SourceMap } from '@volar/source-map';
-import type * as ts from 'typescript';
-import type { CodeInformation, Language, LanguagePlugin, SourceScript, VirtualCode } from './lib/types';
+import type { Language, LanguagePlugin, SourceScript, VirtualCode } from './lib/types';
 export declare function createLanguage<T>(plugins: LanguagePlugin<T>[], scriptRegistry: Map<T, SourceScript<T>>, sync: (id: T) => void): Language<T>;
-export declare function updateVirtualCodeMapOfMap<T>(virtualCode: VirtualCode, mapOfMap: Map<T, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>, getSourceSnapshot: (source: string | undefined) => [T, ts.IScriptSnapshot] | undefined): void;
 export declare function forEachEmbeddedCode(virtualCode: VirtualCode): Generator<VirtualCode>;

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.forEachEmbeddedCode = exports.updateVirtualCodeMapOfMap = exports.createLanguage = void 0;
+exports.forEachEmbeddedCode = exports.createLanguage = void 0;
 __exportStar(require("@volar/source-map"), exports);
 __exportStar(require("./lib/editorFeatures"), exports);
 __exportStar(require("./lib/linkedCodeMap"), exports);
@@ -23,14 +23,22 @@ __exportStar(require("./lib/utils"), exports);
 const source_map_1 = require("@volar/source-map");
 const linkedCodeMap_1 = require("./lib/linkedCodeMap");
 function createLanguage(plugins, scriptRegistry, sync) {
-    const virtualCodeToSourceFileMap = new WeakMap();
-    const virtualCodeToMaps = new WeakMap();
+    const virtualCodeToSourceScriptMap = new WeakMap();
+    const virtualCodeToSourceMap = new WeakMap();
     const virtualCodeToLinkedCodeMap = new WeakMap();
     return {
         plugins,
         scripts: {
+            fromVirtualCode(virtualCode) {
+                return virtualCodeToSourceScriptMap.get(virtualCode);
+            },
             get(id) {
                 sync(id);
+                const result = scriptRegistry.get(id);
+                // The sync function provider may not always call the set function due to caching, so it is necessary to explicitly check isAssociationDirty.
+                if (result?.isAssociationDirty) {
+                    this.set(id, result.snapshot, result.languageId);
+                }
                 return scriptRegistry.get(id);
             },
             set(id, snapshot, languageId, _plugins = plugins) {
@@ -46,23 +54,36 @@ function createLanguage(plugins, scriptRegistry, sync) {
                     console.warn(`languageId not found for ${id}`);
                     return;
                 }
+                let associatedOnly = false;
+                for (const plugin of plugins) {
+                    if (plugin.isAssociatedFileOnly?.(id, languageId)) {
+                        associatedOnly = true;
+                        break;
+                    }
+                }
                 if (scriptRegistry.has(id)) {
                     const sourceScript = scriptRegistry.get(id);
-                    if (sourceScript.languageId !== languageId) {
-                        // languageId changed
+                    if (sourceScript.languageId !== languageId || sourceScript.associatedOnly !== associatedOnly) {
                         this.delete(id);
                         return this.set(id, snapshot, languageId);
                     }
-                    else if (sourceScript.snapshot !== snapshot) {
+                    else if (associatedOnly) {
+                        sourceScript.snapshot = snapshot;
+                    }
+                    else if (sourceScript.isAssociationDirty || sourceScript.snapshot !== snapshot) {
                         // snapshot updated
                         sourceScript.snapshot = snapshot;
+                        const codegenCtx = prepareCreateVirtualCode(sourceScript);
                         if (sourceScript.generated) {
-                            const newVirtualCode = sourceScript.generated.languagePlugin.updateVirtualCode?.(id, sourceScript.generated.root, snapshot);
+                            const { updateVirtualCode, createVirtualCode } = sourceScript.generated.languagePlugin;
+                            const newVirtualCode = updateVirtualCode
+                                ? updateVirtualCode(id, sourceScript.generated.root, snapshot, codegenCtx)
+                                : createVirtualCode?.(id, languageId, snapshot, codegenCtx);
                             if (newVirtualCode) {
                                 sourceScript.generated.root = newVirtualCode;
                                 sourceScript.generated.embeddedCodes.clear();
                                 for (const code of forEachEmbeddedCode(sourceScript.generated.root)) {
-                                    virtualCodeToSourceFileMap.set(code, sourceScript);
+                                    virtualCodeToSourceScriptMap.set(code, sourceScript);
                                     sourceScript.generated.embeddedCodes.set(code.id, code);
                                 }
                                 return sourceScript;
@@ -72,6 +93,7 @@ function createLanguage(plugins, scriptRegistry, sync) {
                                 return;
                             }
                         }
+                        triggerTargetsDirty(sourceScript);
                     }
                     else {
                         // not changed
@@ -80,10 +102,20 @@ function createLanguage(plugins, scriptRegistry, sync) {
                 }
                 else {
                     // created
-                    const sourceScript = { id, languageId, snapshot };
+                    const sourceScript = {
+                        id: id,
+                        languageId,
+                        snapshot,
+                        associatedIds: new Set(),
+                        targetIds: new Set(),
+                        associatedOnly
+                    };
                     scriptRegistry.set(id, sourceScript);
+                    if (associatedOnly) {
+                        return sourceScript;
+                    }
                     for (const languagePlugin of _plugins) {
-                        const virtualCode = languagePlugin.createVirtualCode?.(id, languageId, snapshot);
+                        const virtualCode = languagePlugin.createVirtualCode?.(id, languageId, snapshot, prepareCreateVirtualCode(sourceScript));
                         if (virtualCode) {
                             sourceScript.generated = {
                                 root: virtualCode,
@@ -91,7 +123,7 @@ function createLanguage(plugins, scriptRegistry, sync) {
                                 embeddedCodes: new Map(),
                             };
                             for (const code of forEachEmbeddedCode(virtualCode)) {
-                                virtualCodeToSourceFileMap.set(code, sourceScript);
+                                virtualCodeToSourceScriptMap.set(code, sourceScript);
                                 sourceScript.generated.embeddedCodes.set(code.id, code);
                             }
                             break;
@@ -101,86 +133,90 @@ function createLanguage(plugins, scriptRegistry, sync) {
                 }
             },
             delete(id) {
-                const value = scriptRegistry.get(id);
-                if (value) {
-                    if (value.generated) {
-                        value.generated.languagePlugin.disposeVirtualCode?.(id, value.generated.root);
-                    }
+                const sourceScript = scriptRegistry.get(id);
+                if (sourceScript) {
+                    sourceScript.generated?.languagePlugin.disposeVirtualCode?.(id, sourceScript.generated.root);
                     scriptRegistry.delete(id);
+                    triggerTargetsDirty(sourceScript);
                 }
             },
         },
         maps: {
-            get(virtualCode, scriptId) {
-                if (!scriptId) {
-                    const sourceScript = virtualCodeToSourceFileMap.get(virtualCode);
-                    if (!sourceScript) {
-                        return;
-                    }
-                    scriptId = sourceScript.id;
+            get(virtualCode, sourceScript, mappings) {
+                let mapCache = virtualCodeToSourceMap.get(virtualCode.snapshot);
+                if (!mapCache) {
+                    virtualCodeToSourceMap.set(virtualCode.snapshot, mapCache = new WeakMap());
                 }
-                for (const [id, [_snapshot, map]] of this.forEach(virtualCode)) {
-                    if (id === scriptId) {
-                        return map;
-                    }
+                if (!mapCache.has(sourceScript.snapshot)) {
+                    mapCache.set(sourceScript.snapshot, new source_map_1.SourceMap(mappings ?? virtualCode.mappings));
                 }
+                return mapCache.get(sourceScript.snapshot);
             },
-            forEach(virtualCode) {
-                let map = virtualCodeToMaps.get(virtualCode.snapshot);
-                if (!map) {
-                    map = new Map();
-                    virtualCodeToMaps.set(virtualCode.snapshot, map);
-                }
-                updateVirtualCodeMapOfMap(virtualCode, map, id => {
-                    if (id) {
-                        throw 'not implemented';
-                        // const sourceScript = sourceScripts.get(id)!;
-                        // return [id, sourceScript.snapshot];
-                    }
-                    else {
-                        const sourceScript = virtualCodeToSourceFileMap.get(virtualCode);
-                        return [sourceScript.id, sourceScript.snapshot];
+            *forEach(virtualCode) {
+                const sourceScript = virtualCodeToSourceScriptMap.get(virtualCode);
+                yield [
+                    sourceScript.id,
+                    sourceScript.snapshot,
+                    this.get(virtualCode, sourceScript),
+                ];
+                if (virtualCode.associatedScriptMappings) {
+                    for (const [relatedScriptId, relatedMappings] of virtualCode.associatedScriptMappings) {
+                        const relatedSourceScript = scriptRegistry.get(relatedScriptId);
+                        if (relatedSourceScript) {
+                            yield [
+                                relatedSourceScript.id,
+                                relatedSourceScript.snapshot,
+                                this.get(virtualCode, relatedSourceScript, relatedMappings),
+                            ];
+                        }
                     }
-                });
-                return map;
+                }
             },
         },
         linkedCodeMaps: {
             get(virtualCode) {
-                if (!virtualCodeToLinkedCodeMap.has(virtualCode.snapshot)) {
-                    virtualCodeToLinkedCodeMap.set(virtualCode.snapshot, virtualCode.linkedCodeMappings
-                        ? new linkedCodeMap_1.LinkedCodeMap(virtualCode.linkedCodeMappings)
-                        : undefined);
+                const sourceScript = virtualCodeToSourceScriptMap.get(virtualCode);
+                let mapCache = virtualCodeToLinkedCodeMap.get(virtualCode.snapshot);
+                if (mapCache?.[0] !== sourceScript.snapshot) {
+                    virtualCodeToLinkedCodeMap.set(virtualCode.snapshot, mapCache = [
+                        sourceScript.snapshot,
+                        virtualCode.linkedCodeMappings
+                            ? new linkedCodeMap_1.LinkedCodeMap(virtualCode.linkedCodeMappings)
+                            : undefined,
+                    ]);
                 }
-                return virtualCodeToLinkedCodeMap.get(virtualCode.snapshot);
+                return mapCache[1];
             },
         },
     };
-}
-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([])]);
-        }
+    function triggerTargetsDirty(sourceScript) {
+        sourceScript.targetIds.forEach(id => {
+            const sourceScript = scriptRegistry.get(id);
+            if (sourceScript) {
+                sourceScript.isAssociationDirty = true;
+            }
+        });
     }
-    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 (!mapOfMap.has(source[0]) || mapOfMap.get(source[0])[0] !== source[1]) {
-            mapOfMap.set(source[0], [source[1], new source_map_1.SourceMap(virtualCode.mappings.filter(mapping2 => mapping2.source === mapping.source))]);
+    function prepareCreateVirtualCode(sourceScript) {
+        for (const id of sourceScript.associatedIds) {
+            scriptRegistry.get(id)?.targetIds.delete(sourceScript.id);
         }
+        sourceScript.associatedIds.clear();
+        sourceScript.isAssociationDirty = false;
+        return {
+            getAssociatedScript(id) {
+                sync(id);
+                const relatedSourceScript = scriptRegistry.get(id);
+                if (relatedSourceScript) {
+                    relatedSourceScript.targetIds.add(sourceScript.id);
+                    sourceScript.associatedIds.add(relatedSourceScript.id);
+                }
+                return relatedSourceScript;
+            },
+        };
     }
 }
-exports.updateVirtualCodeMapOfMap = updateVirtualCodeMapOfMap;
+exports.createLanguage = createLanguage;
 function* forEachEmbeddedCode(virtualCode) {
     yield virtualCode;
     if (virtualCode.embeddedCodes) {

package/lib/linkedCodeMap.d.ts

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

package/lib/types.d.ts

@@ -1,16 +1,17 @@
 import type { Mapping, SourceMap } from '@volar/source-map';
 import type * as ts from 'typescript';
 import type { LinkedCodeMap } from './linkedCodeMap';
-export interface Language<T> {
+export interface Language<T = unknown> {
     plugins: LanguagePlugin<T>[];
     scripts: {
         get(id: T): SourceScript<T> | undefined;
         set(id: T, snapshot: ts.IScriptSnapshot, languageId?: string, plugins?: LanguagePlugin<T>[]): SourceScript<T> | undefined;
         delete(id: T): void;
+        fromVirtualCode(virtualCode: VirtualCode): SourceScript<T>;
     };
     maps: {
-        get(virtualCode: VirtualCode, scriptId?: T): SourceMap<CodeInformation> | undefined;
-        forEach(virtualCode: VirtualCode): Map<T, [ts.IScriptSnapshot, SourceMap<CodeInformation>]>;
+        get(virtualCode: VirtualCode, sourceScript: SourceScript<T>, mappings?: Mapping<CodeInformation>[]): SourceMap<CodeInformation>;
+        forEach(virtualCode: VirtualCode): Generator<[id: T, snapshot: ts.IScriptSnapshot, map: SourceMap<CodeInformation>]>;
     };
     linkedCodeMaps: {
         get(virtualCode: VirtualCode): LinkedCodeMap | undefined;
@@ -27,10 +28,14 @@ export interface Language<T> {
         asFileName(scriptId: T): string;
     };
 }
-export interface SourceScript<T> {
+export interface SourceScript<T = unknown> {
     id: T;
     languageId: string;
     snapshot: ts.IScriptSnapshot;
+    targetIds: Set<T>;
+    associatedIds: Set<T>;
+    associatedOnly: boolean;
+    isAssociationDirty?: boolean;
     generated?: {
         root: VirtualCode;
         languagePlugin: LanguagePlugin<T>;
@@ -43,6 +48,7 @@ export interface VirtualCode {
     languageId: string;
     snapshot: ts.IScriptSnapshot;
     mappings: CodeMapping[];
+    associatedScriptMappings?: Map<unknown, CodeMapping[]>;
     embeddedCodes?: VirtualCode[];
     linkedCodeMappings?: Mapping[];
 }
@@ -75,31 +81,54 @@ export interface TypeScriptServiceScript {
     code: VirtualCode;
     extension: '.ts' | '.js' | '.mts' | '.mjs' | '.cjs' | '.cts' | '.d.ts' | string;
     scriptKind: ts.ScriptKind;
+    /** See #188 */
+    preventLeadingOffset?: boolean;
 }
 export interface TypeScriptExtraServiceScript extends TypeScriptServiceScript {
     fileName: string;
 }
-export interface LanguagePlugin<T, K extends VirtualCode = VirtualCode> {
+export interface LanguagePlugin<T = unknown, K extends VirtualCode = VirtualCode> {
+    /**
+     * For files that are not opened in the IDE, the language ID will not be synchronized to the language server, so a hook is needed to parse the language ID of files that are known extension but not opened in the IDE.
+     */
     getLanguageId(scriptId: T): string | undefined;
-    createVirtualCode?(scriptId: T, languageId: string, snapshot: ts.IScriptSnapshot): K | undefined;
-    updateVirtualCode?(scriptId: T, virtualCode: K, newSnapshot: ts.IScriptSnapshot): K | undefined;
+    /**
+     * Generate a virtual code.
+     */
+    createVirtualCode?(scriptId: T, languageId: string, snapshot: ts.IScriptSnapshot, ctx: CodegenContext<T>): K | undefined;
+    /**
+     * Incremental update a virtual code. If not provide, call createVirtualCode again.
+     */
+    updateVirtualCode?(scriptId: T, virtualCode: K, newSnapshot: ts.IScriptSnapshot, ctx: CodegenContext<T>): K | undefined;
+    /**
+     * Cleanup a virtual code.
+     */
     disposeVirtualCode?(scriptId: T, virtualCode: K): void;
-    typescript?: {
-        /**
-         * LSP + TS Plugin
-         */
-        extraFileExtensions: ts.FileExtensionInfo[];
-        /**
-         * LSP + TS Plugin
-         */
-        getServiceScript(rootVirtualCode: K): TypeScriptServiceScript | undefined;
-        /**
-         * LSP only
-         */
-        getExtraServiceScripts?(fileName: string, rootVirtualCode: K): TypeScriptExtraServiceScript[];
-        /**
-         * LSP only
-         */
-        resolveLanguageServiceHost?(host: ts.LanguageServiceHost): ts.LanguageServiceHost;
-    };
+    /**
+     * Some file types should not be parsed or processed as TypeScript files,
+     * as they are used only as sources for generated files.
+     *
+     * This functionality is required only in TS plugin mode.
+     */
+    isAssociatedFileOnly?(scriptId: T, languageId: string): boolean;
+    typescript?: TypeScriptGenericOptions<K> & TypeScriptNonTSPluginOptions<K>;
+}
+export interface CodegenContext<T = unknown> {
+    getAssociatedScript(scriptId: T): SourceScript<T> | undefined;
+}
+/**
+ * The following options available to all situations.
+ */
+interface TypeScriptGenericOptions<K> {
+    extraFileExtensions: ts.FileExtensionInfo[];
+    resolveHiddenExtensions?: boolean;
+    getServiceScript(root: K): TypeScriptServiceScript | undefined;
+}
+/**
+ * The following options will not be available in TS plugin.
+ */
+interface TypeScriptNonTSPluginOptions<K> {
+    getExtraServiceScripts?(fileName: string, rootVirtualCode: K): TypeScriptExtraServiceScript[];
+    resolveLanguageServiceHost?(host: ts.LanguageServiceHost): ts.LanguageServiceHost;
 }
+export {};

package/package.json

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