@volar/typescript 2.4.11 → 2.4.12

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,130 +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) {
-                            if (extensions.some(ext => fileName.endsWith(ext))) {
-                                return emptySnapshot;
-                            }
-                            if (getScriptInfo(fileName)?.isScriptOpen()) {
-                                return emptySnapshot;
-                            }
-                        }
-                        return getScriptSnapshot(fileName);
-                    };
-                    info.languageServiceHost.getScriptVersion = fileName => {
-                        if (!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 (!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, _, 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);
-                            }
-                        });
-                        initialize(language);
-                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
-                        setup?.(language);
-                        initialized = true;
+                    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();
                         }
                     });
                 }
                 return info.languageService;
-                function getScriptInfo(fileName) {
-                    // getSnapshot could be crashed if the file is too large
-                    try {
-                        return info.project.getScriptInfo(fileName);
-                    }
-                    catch { }
-                }
-            },
-            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,97 +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 getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
-                    const language = (0, language_core_1.createLanguage)([
-                        ...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);
-                        }
-                    });
+                    // 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;
-                function getScriptInfo(fileName) {
-                    // getSnapshot could be crashed if the file is too large
-                    try {
-                        return info.project.getScriptInfo(fileName);
-                    }
-                    catch { }
-                }
-            },
-            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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "2.4.11",
+	"version": "2.4.12",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,14 +12,14 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.11",
+		"@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.11"
+		"@volar/language-service": "2.4.12"
 	},
-	"gitHead": "42ccae005cc8516e07ad38f4d7730cab9b723340"
+	"gitHead": "17b9b8a1f522afd1aad1e598d2fd935680d8a8d7"
 }