@volar/typescript 2.4.10 → 2.4.12

package/lib/node/decorateLanguageServiceHost.js

@@ -55,7 +55,7 @@ function decorateLanguageServiceHost(ts, language, languageServiceHost) {
         }
     }
     languageServiceHost.getScriptSnapshot = fileName => {
-        const virtualScript = updateVirtualScript(fileName);
+        const virtualScript = updateVirtualScript(fileName, true);
         if (virtualScript) {
             return virtualScript.snapshot;
         }
@@ -63,14 +63,14 @@ function decorateLanguageServiceHost(ts, language, languageServiceHost) {
     };
     if (getScriptKind) {
         languageServiceHost.getScriptKind = fileName => {
-            const virtualScript = updateVirtualScript(fileName);
+            const virtualScript = updateVirtualScript(fileName, false);
             if (virtualScript) {
                 return virtualScript.scriptKind;
             }
             return getScriptKind(fileName);
         };
     }
-    function updateVirtualScript(fileName) {
+    function updateVirtualScript(fileName, shouldRegister) {
         if (crashFileNames.has(fileName)) {
             return;
         }
@@ -89,7 +89,7 @@ function decorateLanguageServiceHost(ts, language, languageServiceHost) {
         let script = scripts.get(fileName);
         if (!script || script[0] !== version) {
             script = [version];
-            const sourceScript = language.scripts.get(fileName);
+            const sourceScript = language.scripts.get(fileName, undefined, shouldRegister);
             if (sourceScript?.generated) {
                 const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
                 if (serviceScript) {

package/lib/node/proxyLanguageService.d.ts

@@ -1,5 +1,17 @@
 import { Language } from '@volar/language-core';
 import type * as ts from 'typescript';
+/**
+ * Creates and returns a Proxy around the base TypeScript LanguageService.
+ *
+ * This is used by the Volar TypeScript Plugin (which can be created by `createLanguageServicePlugin`
+ * and `createAsyncLanguageServicePlugin`) as an adapter layer between the TypeScript Language Service
+ * plugin API (see https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin)
+ * and a Volar `Language`.
+ *
+ * Once the `initialize` method is called, the proxy will begin intercepting requests and
+ * enhancing the default behavior of the LanguageService with enhancements based on
+ * the Volar `Language` that has been passed to `initialize`.
+ */
 export declare function createProxyLanguageService(languageService: ts.LanguageService): {
     initialize(language: Language<string>): void;
     proxy: ts.LanguageService;

package/lib/node/proxyLanguageService.js

@@ -6,6 +6,18 @@ const dedupe_1 = require("./dedupe");
 const transform_1 = require("./transform");
 const utils_1 = require("./utils");
 const windowsPathReg = /\\/g;
+/**
+ * Creates and returns a Proxy around the base TypeScript LanguageService.
+ *
+ * This is used by the Volar TypeScript Plugin (which can be created by `createLanguageServicePlugin`
+ * and `createAsyncLanguageServicePlugin`) as an adapter layer between the TypeScript Language Service
+ * plugin API (see https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin)
+ * and a Volar `Language`.
+ *
+ * Once the `initialize` method is called, the proxy will begin intercepting requests and
+ * enhancing the default behavior of the LanguageService with enhancements based on
+ * the Volar `Language` that has been passed to `initialize`.
+ */
 function createProxyLanguageService(languageService) {
     const proxyCache = new Map();
     let getProxyMethod;

package/lib/node/transform.d.ts

@@ -2,6 +2,12 @@ import type { CodeInformation, SourceScript } from '@volar/language-core';
 import { Language } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { TypeScriptServiceScript } from '../..';
+/**
+ * This file contains a number of facilities for transforming `ts.Diagnostic`s returned
+ * from the  base TypeScript LanguageService, which reference locations in generated
+ * TS code (e.g. the TypeScript codegen'd from the script portion of a .vue file) into locations
+ * in the script portion of the .vue file.
+ */
 export declare function transformCallHierarchyItem(language: Language<string>, item: ts.CallHierarchyItem, fallbackToAnyMatch: boolean, filter: (data: CodeInformation) => boolean): ts.CallHierarchyItem;
 export declare function transformDiagnostic<T extends ts.Diagnostic>(language: Language<string>, diagnostic: T, program: ts.Program | undefined, isTsc: boolean): T | undefined;
 export declare function fillSourceFileText(language: Language<string>, sourceFile: ts.SourceFile): void;

package/lib/node/transform.js

@@ -19,6 +19,12 @@ const language_core_1 = require("@volar/language-core");
 const utils_1 = require("./utils");
 const transformedDiagnostics = new WeakMap();
 const transformedSourceFile = new WeakSet();
+/**
+ * This file contains a number of facilities for transforming `ts.Diagnostic`s returned
+ * from the  base TypeScript LanguageService, which reference locations in generated
+ * TS code (e.g. the TypeScript codegen'd from the script portion of a .vue file) into locations
+ * in the script portion of the .vue file.
+ */
 function transformCallHierarchyItem(language, item, fallbackToAnyMatch, filter) {
     const span = transformSpan(language, item.file, item.span, fallbackToAnyMatch, filter);
     const selectionSpan = transformSpan(language, item.file, item.selectionSpan, fallbackToAnyMatch, filter);

package/lib/quickstart/createAsyncLanguageServicePlugin.d.ts

@@ -1,6 +1,22 @@
-import { Language, LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function createAsyncLanguageServicePlugin(extensions: string[], getScriptKindForExtraExtensions: ts.ScriptKind | ((fileName: string) => ts.ScriptKind), create: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<{
-    languagePlugins: LanguagePlugin<string>[];
-    setup?: (language: Language<string>) => void;
-}>): ts.server.PluginModuleFactory;
+import type { createPluginCallbackAsync } from './languageServicePluginCommon';
+/**
+ * Creates and returns a TS Service Plugin that supports async initialization.
+ * Essentially, this functions the same as `createLanguageServicePlugin`, but supports
+ * use cases in which the plugin callback must be async. For example in mdx-analyzer
+ * and Glint, this async variant is required because Glint + mdx-analyzer are written
+ * in ESM and get transpiled to CJS, which requires usage of `await import()` to load
+ * the necessary dependencies and fully initialize the plugin.
+ *
+ * To handle the period of time in which the plugin is initializing, this async
+ * variant stubs a number of methods on the LanguageServiceHost to handle the uninitialized state.
+ *
+ * Additionally, this async variant requires a few extra args pertaining to
+ * file extensions intended to be handled by the TS Plugin. In the synchronous variant,
+ * these can be synchronously inferred from elsewhere but for the async variant, they
+ * need to be passed in.
+ *
+ * See https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin for
+ * more information.
+ */
+export declare function createAsyncLanguageServicePlugin(extensions: string[], getScriptKindForExtraExtensions: ts.ScriptKind | ((fileName: string) => ts.ScriptKind), createPluginCallbackAsync: createPluginCallbackAsync): ts.server.PluginModuleFactory;

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -1,109 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAsyncLanguageServicePlugin = createAsyncLanguageServicePlugin;
-const language_core_1 = require("@volar/language-core");
-const common_1 = require("../common");
 const proxyLanguageService_1 = require("../node/proxyLanguageService");
-const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
-const createLanguageServicePlugin_1 = require("./createLanguageServicePlugin");
-function createAsyncLanguageServicePlugin(extensions, getScriptKindForExtraExtensions, create) {
+const languageServicePluginCommon_1 = require("./languageServicePluginCommon");
+/**
+ * Creates and returns a TS Service Plugin that supports async initialization.
+ * Essentially, this functions the same as `createLanguageServicePlugin`, but supports
+ * use cases in which the plugin callback must be async. For example in mdx-analyzer
+ * and Glint, this async variant is required because Glint + mdx-analyzer are written
+ * in ESM and get transpiled to CJS, which requires usage of `await import()` to load
+ * the necessary dependencies and fully initialize the plugin.
+ *
+ * To handle the period of time in which the plugin is initializing, this async
+ * variant stubs a number of methods on the LanguageServiceHost to handle the uninitialized state.
+ *
+ * Additionally, this async variant requires a few extra args pertaining to
+ * file extensions intended to be handled by the TS Plugin. In the synchronous variant,
+ * these can be synchronously inferred from elsewhere but for the async variant, they
+ * need to be passed in.
+ *
+ * See https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin for
+ * more information.
+ */
+function createAsyncLanguageServicePlugin(extensions, getScriptKindForExtraExtensions, createPluginCallbackAsync) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
             create(info) {
-                if (!createLanguageServicePlugin_1.decoratedLanguageServices.has(info.languageService)
-                    && !createLanguageServicePlugin_1.decoratedLanguageServiceHosts.has(info.languageServiceHost)) {
-                    createLanguageServicePlugin_1.decoratedLanguageServices.add(info.languageService);
-                    createLanguageServicePlugin_1.decoratedLanguageServiceHosts.add(info.languageServiceHost);
-                    const emptySnapshot = ts.ScriptSnapshot.fromString('');
-                    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
-                    const getScriptVersion = info.languageServiceHost.getScriptVersion.bind(info.languageServiceHost);
-                    const getScriptKind = info.languageServiceHost.getScriptKind?.bind(info.languageServiceHost);
-                    const getProjectVersion = info.languageServiceHost.getProjectVersion?.bind(info.languageServiceHost);
-                    let initialized = false;
-                    info.languageServiceHost.getScriptSnapshot = fileName => {
-                        if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
-                            return emptySnapshot;
-                        }
-                        return getScriptSnapshot(fileName);
-                    };
-                    info.languageServiceHost.getScriptVersion = fileName => {
-                        if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
-                            return 'initializing...';
-                        }
-                        return getScriptVersion(fileName);
-                    };
-                    if (getScriptKind) {
-                        info.languageServiceHost.getScriptKind = fileName => {
-                            if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
-                                // bypass upstream bug https://github.com/microsoft/TypeScript/issues/57631
-                                // TODO: check if the bug is fixed in 5.5
-                                if (typeof getScriptKindForExtraExtensions === 'function') {
-                                    return getScriptKindForExtraExtensions(fileName);
-                                }
-                                else {
-                                    return getScriptKindForExtraExtensions;
-                                }
-                            }
-                            return getScriptKind(fileName);
-                        };
-                    }
-                    if (getProjectVersion) {
-                        info.languageServiceHost.getProjectVersion = () => {
-                            if (!initialized) {
-                                return getProjectVersion() + ',initializing...';
-                            }
-                            return getProjectVersion();
-                        };
-                    }
+                if (!(0, languageServicePluginCommon_1.isHasAlreadyDecoratedLanguageService)(info)) {
+                    const state = decorateWithAsyncInitializationHandling(ts, info, extensions, getScriptKindForExtraExtensions);
                     const { proxy, initialize } = (0, proxyLanguageService_1.createProxyLanguageService)(info.languageService);
                     info.languageService = proxy;
-                    create(ts, info).then(({ languagePlugins, setup }) => {
-                        const language = (0, language_core_1.createLanguage)([
-                            ...languagePlugins,
-                            { getLanguageId: common_1.resolveFileLanguageId },
-                        ], new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames), fileName => {
-                            try { // getSnapshot could be crashed if the file is too large
-                                let snapshot = info.project.getScriptInfo(fileName)?.getSnapshot();
-                                if (!snapshot) {
-                                    // trigger projectService.getOrCreateScriptInfoNotOpenedByClient
-                                    info.project.getScriptVersion(fileName);
-                                    snapshot = info.project.getScriptInfo(fileName)?.getSnapshot();
-                                }
-                                if (snapshot) {
-                                    language.scripts.set(fileName, snapshot);
-                                }
-                                else {
-                                    language.scripts.delete(fileName);
-                                }
-                            }
-                            catch { }
-                        });
-                        initialize(language);
-                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
-                        setup?.(language);
+                    createPluginCallbackAsync(ts, info).then(createPluginResult => {
+                        (0, languageServicePluginCommon_1.createLanguageCommon)(createPluginResult, ts, info, initialize);
+                        state.initialized = true;
                         if ('markAsDirty' in info.project && typeof info.project.markAsDirty === 'function') {
+                            // This is an attempt to mark the project as dirty so that in case the IDE/tsserver
+                            // already finished a first pass of generating diagnostics (or other things), another
+                            // pass will be triggered which should hopefully make use of this now-initialized plugin.
                             info.project.markAsDirty();
                         }
-                        initialized = true;
                     });
                 }
                 return info.languageService;
             },
-            getExternalFiles(project, updateLevel = 0) {
-                if (updateLevel >= 1
-                    || !createLanguageServicePlugin_1.externalFiles.has(project)) {
-                    const oldFiles = createLanguageServicePlugin_1.externalFiles.get(project);
-                    const newFiles = extensions.length ? (0, decorateLanguageServiceHost_1.searchExternalFiles)(ts, project, extensions) : [];
-                    createLanguageServicePlugin_1.externalFiles.set(project, newFiles);
-                    if (oldFiles && !(0, createLanguageServicePlugin_1.arrayItemsEqual)(oldFiles, newFiles)) {
-                        project.refreshDiagnostics();
-                    }
-                }
-                return createLanguageServicePlugin_1.externalFiles.get(project);
-            },
+            getExternalFiles: (0, languageServicePluginCommon_1.makeGetExternalFiles)(ts),
         };
         return pluginModule;
     };
 }
+function decorateWithAsyncInitializationHandling(ts, info, extensions, getScriptKindForExtraExtensions) {
+    const emptySnapshot = ts.ScriptSnapshot.fromString('');
+    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
+    const getScriptVersion = info.languageServiceHost.getScriptVersion.bind(info.languageServiceHost);
+    const getScriptKind = info.languageServiceHost.getScriptKind?.bind(info.languageServiceHost);
+    const getProjectVersion = info.languageServiceHost.getProjectVersion?.bind(info.languageServiceHost);
+    const getScriptInfo = (0, languageServicePluginCommon_1.makeGetScriptInfoWithLargeFileFailsafe)(info);
+    const state = { initialized: false };
+    info.languageServiceHost.getScriptSnapshot = fileName => {
+        if (!state.initialized) {
+            if (extensions.some(ext => fileName.endsWith(ext))) {
+                return emptySnapshot;
+            }
+            if (getScriptInfo(fileName)?.isScriptOpen()) {
+                return emptySnapshot;
+            }
+        }
+        return getScriptSnapshot(fileName);
+    };
+    info.languageServiceHost.getScriptVersion = fileName => {
+        if (!state.initialized) {
+            if (extensions.some(ext => fileName.endsWith(ext))) {
+                return 'initializing...';
+            }
+            if (getScriptInfo(fileName)?.isScriptOpen()) {
+                return getScriptVersion(fileName) + ',initializing...';
+            }
+        }
+        return getScriptVersion(fileName);
+    };
+    if (getScriptKind) {
+        info.languageServiceHost.getScriptKind = fileName => {
+            if (!state.initialized && extensions.some(ext => fileName.endsWith(ext))) {
+                // bypass upstream bug https://github.com/microsoft/TypeScript/issues/57631
+                // TODO: check if the bug is fixed in 5.5
+                if (typeof getScriptKindForExtraExtensions === 'function') {
+                    return getScriptKindForExtraExtensions(fileName);
+                }
+                else {
+                    return getScriptKindForExtraExtensions;
+                }
+            }
+            return getScriptKind(fileName);
+        };
+    }
+    if (getProjectVersion) {
+        info.languageServiceHost.getProjectVersion = () => {
+            if (!state.initialized) {
+                return getProjectVersion() + ',initializing...';
+            }
+            return getProjectVersion();
+        };
+    }
+    return state;
+}
 //# sourceMappingURL=createAsyncLanguageServicePlugin.js.map

package/lib/quickstart/createLanguageServicePlugin.d.ts

@@ -1,11 +1,9 @@
-import { Language, LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare const externalFiles: WeakMap<ts.server.Project, string[]>;
-export declare const projectExternalFileExtensions: WeakMap<ts.server.Project, string[]>;
-export declare const decoratedLanguageServices: WeakSet<ts.LanguageService>;
-export declare const decoratedLanguageServiceHosts: WeakSet<ts.LanguageServiceHost>;
-export declare function createLanguageServicePlugin(create: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => {
-    languagePlugins: LanguagePlugin<string>[];
-    setup?: (language: Language<string>) => void;
-}): ts.server.PluginModuleFactory;
-export declare function arrayItemsEqual(a: string[], b: string[]): boolean;
+import type { createPluginCallbackSync } from './languageServicePluginCommon';
+/**
+ * Creates and returns a TS Service Plugin using Volar primitives.
+ *
+ * See https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin for
+ * more information.
+ */
+export declare function createLanguageServicePlugin(createPluginCallback: createPluginCallbackSync): ts.server.PluginModuleFactory;

package/lib/quickstart/createLanguageServicePlugin.js

@@ -1,85 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoratedLanguageServiceHosts = exports.decoratedLanguageServices = exports.projectExternalFileExtensions = exports.externalFiles = void 0;
 exports.createLanguageServicePlugin = createLanguageServicePlugin;
-exports.arrayItemsEqual = arrayItemsEqual;
-const language_core_1 = require("@volar/language-core");
-const common_1 = require("../common");
 const proxyLanguageService_1 = require("../node/proxyLanguageService");
-const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
-exports.externalFiles = new WeakMap();
-exports.projectExternalFileExtensions = new WeakMap();
-exports.decoratedLanguageServices = new WeakSet();
-exports.decoratedLanguageServiceHosts = new WeakSet();
-function createLanguageServicePlugin(create) {
+const languageServicePluginCommon_1 = require("./languageServicePluginCommon");
+/**
+ * Creates and returns a TS Service Plugin using Volar primitives.
+ *
+ * See https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin for
+ * more information.
+ */
+function createLanguageServicePlugin(createPluginCallback) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
             create(info) {
-                if (!exports.decoratedLanguageServices.has(info.languageService)
-                    && !exports.decoratedLanguageServiceHosts.has(info.languageServiceHost)) {
-                    exports.decoratedLanguageServices.add(info.languageService);
-                    exports.decoratedLanguageServiceHosts.add(info.languageServiceHost);
-                    const { languagePlugins, setup } = create(ts, info);
-                    const extensions = languagePlugins
+                if (!(0, languageServicePluginCommon_1.isHasAlreadyDecoratedLanguageService)(info)) {
+                    const createPluginResult = createPluginCallback(ts, info);
+                    const extensions = createPluginResult.languagePlugins
                         .map(plugin => plugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [])
                         .flat();
-                    exports.projectExternalFileExtensions.set(info.project, extensions);
-                    const language = (0, language_core_1.createLanguage)([
-                        ...languagePlugins,
-                        { getLanguageId: common_1.resolveFileLanguageId },
-                    ], new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames), fileName => {
-                        try { // getSnapshot could be crashed if the file is too large
-                            let snapshot = info.project.getScriptInfo(fileName)?.getSnapshot();
-                            if (!snapshot) {
-                                // trigger projectService.getOrCreateScriptInfoNotOpenedByClient
-                                info.project.getScriptVersion(fileName);
-                                snapshot = info.project.getScriptInfo(fileName)?.getSnapshot();
-                            }
-                            if (snapshot) {
-                                language.scripts.set(fileName, snapshot);
-                            }
-                            else {
-                                language.scripts.delete(fileName);
-                            }
-                        }
-                        catch { }
-                    });
+                    // TODO: this logic does not seem to appear in the async variant
+                    // (createAsyncLanguageServicePlugin)... bug?
+                    languageServicePluginCommon_1.projectExternalFileExtensions.set(info.project, extensions);
                     const { proxy, initialize } = (0, proxyLanguageService_1.createProxyLanguageService)(info.languageService);
                     info.languageService = proxy;
-                    initialize(language);
-                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
-                    setup?.(language);
+                    (0, languageServicePluginCommon_1.createLanguageCommon)(createPluginResult, ts, info, initialize);
                 }
                 return info.languageService;
             },
-            getExternalFiles(project, updateLevel = 0) {
-                if (updateLevel >= 1
-                    || !exports.externalFiles.has(project)) {
-                    const oldFiles = exports.externalFiles.get(project);
-                    const extensions = exports.projectExternalFileExtensions.get(project);
-                    const newFiles = extensions?.length ? (0, decorateLanguageServiceHost_1.searchExternalFiles)(ts, project, extensions) : [];
-                    exports.externalFiles.set(project, newFiles);
-                    if (oldFiles && !arrayItemsEqual(oldFiles, newFiles)) {
-                        project.refreshDiagnostics();
-                    }
-                }
-                return exports.externalFiles.get(project);
-            },
+            getExternalFiles: (0, languageServicePluginCommon_1.makeGetExternalFiles)(ts),
         };
         return pluginModule;
     };
 }
-function arrayItemsEqual(a, b) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    const set = new Set(a);
-    for (const file of b) {
-        if (!set.has(file)) {
-            return false;
-        }
-    }
-    return true;
-}
 //# sourceMappingURL=createLanguageServicePlugin.js.map

package/lib/quickstart/languageServicePluginCommon.d.ts

@@ -0,0 +1,24 @@
+import { Language, LanguagePlugin } from '@volar/language-core/lib/types';
+import type * as ts from 'typescript';
+export declare const externalFiles: WeakMap<ts.server.Project, string[]>;
+export declare const projectExternalFileExtensions: WeakMap<ts.server.Project, string[]>;
+export declare const decoratedLanguageServices: WeakSet<ts.LanguageService>;
+export declare const decoratedLanguageServiceHosts: WeakSet<ts.LanguageServiceHost>;
+/**
+ * Wrap `getScriptInfo` to handle large files that may crash the language service.
+ *
+ * Introduced to fix issues with converting `relatedInformation` (in Diagnostics)
+ * when working with large files.
+ *
+ * https://github.com/volarjs/volar.js/commit/e242709a91e9d2919dc4fa59278dd266fd11e7a3
+ */
+export declare function makeGetScriptInfoWithLargeFileFailsafe(info: ts.server.PluginCreateInfo): (fileName: string) => ts.server.ScriptInfo | undefined;
+export declare function createLanguageCommon(createPluginResult: createPluginCallbackReturnValue, ts: typeof import('typescript'), info: ts.server.PluginCreateInfo, initializeProxiedLanguageService: (language: Language<string>) => void): void;
+export declare const makeGetExternalFiles: (ts: typeof import("typescript")) => (project: ts.server.Project, updateLevel?: number) => string[];
+export type createPluginCallbackReturnValue = {
+    languagePlugins: LanguagePlugin<string>[];
+    setup?: (language: Language<string>) => void;
+};
+export type createPluginCallbackSync = (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => createPluginCallbackReturnValue;
+export type createPluginCallbackAsync = (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<createPluginCallbackReturnValue>;
+export declare function isHasAlreadyDecoratedLanguageService(info: ts.server.PluginCreateInfo): boolean;

package/lib/quickstart/languageServicePluginCommon.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetExternalFiles = exports.decoratedLanguageServiceHosts = exports.decoratedLanguageServices = exports.projectExternalFileExtensions = exports.externalFiles = void 0;
+exports.makeGetScriptInfoWithLargeFileFailsafe = makeGetScriptInfoWithLargeFileFailsafe;
+exports.createLanguageCommon = createLanguageCommon;
+exports.isHasAlreadyDecoratedLanguageService = isHasAlreadyDecoratedLanguageService;
+const language_core_1 = require("@volar/language-core");
+const common_1 = require("../common");
+const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
+exports.externalFiles = new WeakMap();
+exports.projectExternalFileExtensions = new WeakMap();
+exports.decoratedLanguageServices = new WeakSet();
+exports.decoratedLanguageServiceHosts = new WeakSet();
+/**
+ * Wrap `getScriptInfo` to handle large files that may crash the language service.
+ *
+ * Introduced to fix issues with converting `relatedInformation` (in Diagnostics)
+ * when working with large files.
+ *
+ * https://github.com/volarjs/volar.js/commit/e242709a91e9d2919dc4fa59278dd266fd11e7a3
+ */
+function makeGetScriptInfoWithLargeFileFailsafe(info) {
+    return (fileName) => {
+        // getSnapshot could be crashed if the file is too large
+        try {
+            return info.project.getScriptInfo(fileName);
+        }
+        catch { }
+    };
+}
+function createLanguageCommon(createPluginResult, ts, info, initializeProxiedLanguageService) {
+    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
+    const getScriptInfo = makeGetScriptInfoWithLargeFileFailsafe(info);
+    const language = (0, language_core_1.createLanguage)([
+        ...createPluginResult.languagePlugins,
+        { getLanguageId: common_1.resolveFileLanguageId },
+    ], new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames), (fileName, _, shouldRegister) => {
+        let snapshot;
+        if (shouldRegister) {
+            // We need to trigger registration of the script file with the project, see #250
+            snapshot = getScriptSnapshot(fileName);
+        }
+        else {
+            snapshot = getScriptInfo(fileName)?.getSnapshot();
+            if (!snapshot) {
+                // trigger projectService.getOrCreateScriptInfoNotOpenedByClient
+                info.project.getScriptVersion(fileName);
+                snapshot = getScriptInfo(fileName)?.getSnapshot();
+            }
+        }
+        if (snapshot) {
+            language.scripts.set(fileName, snapshot);
+        }
+        else {
+            language.scripts.delete(fileName);
+        }
+    }, targetFileName => {
+        // https://github.com/JetBrains/intellij-plugins/blob/6435723ad88fa296b41144162ebe3b8513f4949b/Angular/src-js/angular-service/src/ngCommands.ts#L88
+        info.session.change({
+            file: targetFileName,
+            line: 1,
+            offset: 1,
+            endLine: 1,
+            endOffset: 1,
+            insertString: '',
+        });
+    });
+    initializeProxiedLanguageService(language);
+    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
+    createPluginResult.setup?.(language);
+}
+const makeGetExternalFiles = (ts) => (project, updateLevel = 0) => {
+    if (updateLevel >= 1
+        || !exports.externalFiles.has(project)) {
+        const oldFiles = exports.externalFiles.get(project);
+        const extensions = exports.projectExternalFileExtensions.get(project);
+        const newFiles = extensions?.length ? (0, decorateLanguageServiceHost_1.searchExternalFiles)(ts, project, extensions) : [];
+        exports.externalFiles.set(project, newFiles);
+        if (oldFiles && !arrayItemsEqual(oldFiles, newFiles)) {
+            project.refreshDiagnostics();
+        }
+    }
+    return exports.externalFiles.get(project);
+};
+exports.makeGetExternalFiles = makeGetExternalFiles;
+function arrayItemsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const set = new Set(a);
+    for (const file of b) {
+        if (!set.has(file)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isHasAlreadyDecoratedLanguageService(info) {
+    if (exports.decoratedLanguageServices.has(info.languageService)
+        || exports.decoratedLanguageServiceHosts.has(info.languageServiceHost)) {
+        return true;
+    }
+    else {
+        exports.decoratedLanguageServices.add(info.languageService);
+        exports.decoratedLanguageServiceHosts.add(info.languageServiceHost);
+        return false;
+    }
+}
+//# sourceMappingURL=languageServicePluginCommon.js.map

package/lib/quickstart/runTsc.d.ts

@@ -7,7 +7,7 @@ export declare let getLanguagePlugins: (ts: typeof import('typescript'), options
 export declare function runTsc(tscPath: string, options: string[] | {
     extraSupportedExtensions: string[];
     extraExtensionsToRemove: string[];
-}, _getLanguagePlugins: typeof getLanguagePlugins): void;
+}, _getLanguagePlugins: typeof getLanguagePlugins, typescriptObject?: string): void;
 /**
  * Replaces the code of typescript to add support for additional extensions and language plugins.
  *
@@ -16,6 +16,7 @@ export declare function runTsc(tscPath: string, options: string[] | {
  * @param extraSupportedExtensions - An array of additional supported extensions.
  * @param extraExtensionsToRemove - An array of extensions to remove.
  * @param getLanguagePluginsFile - The file to get language plugins from.
+ * @param typescriptObject - The object to use as typescript.
  * @returns The modified typescript code.
  */
-export declare function transformTscContent(tsc: string, proxyApiPath: string, extraSupportedExtensions: string[], extraExtensionsToRemove: string[], getLanguagePluginsFile?: string): string;
+export declare function transformTscContent(tsc: string, proxyApiPath: string, extraSupportedExtensions: string[], extraExtensionsToRemove: string[], getLanguagePluginsFile?: string, typescriptObject?: string): string;

package/lib/quickstart/runTsc.js

@@ -4,26 +4,41 @@ exports.getLanguagePlugins = void 0;
 exports.runTsc = runTsc;
 exports.transformTscContent = transformTscContent;
 const fs = require("fs");
+const path = require("path");
 let getLanguagePlugins = () => [];
 exports.getLanguagePlugins = getLanguagePlugins;
-function runTsc(tscPath, options, _getLanguagePlugins) {
+function runTsc(tscPath, options, _getLanguagePlugins, typescriptObject) {
     exports.getLanguagePlugins = _getLanguagePlugins;
+    let extraSupportedExtensions;
+    let extraExtensionsToRemove;
+    if (Array.isArray(options)) {
+        extraSupportedExtensions = options;
+        extraExtensionsToRemove = [];
+    }
+    else {
+        extraSupportedExtensions = options.extraSupportedExtensions;
+        extraExtensionsToRemove = options.extraExtensionsToRemove;
+    }
     const proxyApiPath = require.resolve('../node/proxyCreateProgram');
     const readFileSync = fs.readFileSync;
     fs.readFileSync = (...args) => {
         if (args[0] === tscPath) {
             let tsc = readFileSync(...args);
-            let extraSupportedExtensions;
-            let extraExtensionsToRemove;
-            if (Array.isArray(options)) {
-                extraSupportedExtensions = options;
-                extraExtensionsToRemove = [];
+            try {
+                return transformTscContent(tsc, proxyApiPath, extraSupportedExtensions, extraExtensionsToRemove, __filename, typescriptObject);
             }
-            else {
-                extraSupportedExtensions = options.extraSupportedExtensions;
-                extraExtensionsToRemove = options.extraExtensionsToRemove;
+            catch {
+                // Support the tsc shim used in Typescript v5.7 and up
+                const requireRegex = /module\.exports\s*=\s*require\((?:"|')(?<path>\.\/\w+\.js)(?:"|')\)/;
+                const requirePath = requireRegex.exec(tsc)?.groups?.path;
+                if (requirePath) {
+                    tsc = readFileSync(path.join(path.dirname(tscPath), requirePath), 'utf8');
+                    return transformTscContent(tsc, proxyApiPath, extraSupportedExtensions, extraExtensionsToRemove, __filename, typescriptObject);
+                }
+                else {
+                    throw new Error('Failed to locate tsc module path from shim');
+                }
             }
-            return transformTscContent(tsc, proxyApiPath, extraSupportedExtensions, extraExtensionsToRemove);
         }
         return readFileSync(...args);
     };
@@ -43,9 +58,10 @@ function runTsc(tscPath, options, _getLanguagePlugins) {
  * @param extraSupportedExtensions - An array of additional supported extensions.
  * @param extraExtensionsToRemove - An array of extensions to remove.
  * @param getLanguagePluginsFile - The file to get language plugins from.
+ * @param typescriptObject - The object to use as typescript.
  * @returns The modified typescript code.
  */
-function transformTscContent(tsc, proxyApiPath, extraSupportedExtensions, extraExtensionsToRemove, getLanguagePluginsFile = __filename) {
+function transformTscContent(tsc, proxyApiPath, extraSupportedExtensions, extraExtensionsToRemove, getLanguagePluginsFile = __filename, typescriptObject = `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } )`) {
     const neededPatchExtenstions = extraSupportedExtensions.filter(ext => !extraExtensionsToRemove.includes(ext));
     // Add allow extensions
     if (extraSupportedExtensions.length) {
@@ -71,7 +87,7 @@ function transformTscContent(tsc, proxyApiPath, extraSupportedExtensions, extraE
     // proxy createProgram
     tsc = replace(tsc, /function createProgram\(.+\) {/, s => `var createProgram = require(${JSON.stringify(proxyApiPath)}).proxyCreateProgram(`
         + [
-            `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } )`,
+            typescriptObject,
             `_createProgram`,
             `require(${JSON.stringify(getLanguagePluginsFile)}).getLanguagePlugins`,
         ].join(', ')
@@ -84,7 +100,7 @@ function replace(text, ...[search, replace]) {
     text = text.replace(search, replace);
     const after = text;
     if (after === before) {
-        throw 'Search string not found: ' + JSON.stringify(search.toString());
+        throw new Error('Failed to replace: ' + search);
     }
     return after;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "2.4.10",
+	"version": "2.4.12",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,14 +12,14 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.10",
+		"@volar/language-core": "2.4.12",
 		"path-browserify": "^1.0.1",
 		"vscode-uri": "^3.0.8"
 	},
 	"devDependencies": {
 		"@types/node": "latest",
 		"@types/path-browserify": "latest",
-		"@volar/language-service": "2.4.10"
+		"@volar/language-service": "2.4.12"
 	},
-	"gitHead": "03d1e8b07e1e64921b76b635c7064d7b4fcf63b5"
+	"gitHead": "17b9b8a1f522afd1aad1e598d2fd935680d8a8d7"
 }