typescript 5.4.0-dev.20231114 → 5.4.0-dev.20231115

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231114`;
+var version = `${versionMajorMinor}.0-dev.20231115`;
 
 // src/compiler/core.ts
 var emptyArray = [];

package/lib/tsserver.js

@@ -2330,7 +2330,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231114`;
+var version = `${versionMajorMinor}.0-dev.20231115`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -175255,6 +175255,7 @@ __export(ts_server_exports3, {
   TextStorage: () => TextStorage,
   ThrottledOperations: () => ThrottledOperations,
   TypingsCache: () => TypingsCache,
+  TypingsInstallerAdapter: () => TypingsInstallerAdapter,
   allFilesAreJsOrDts: () => allFilesAreJsOrDts,
   allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
   asNormalizedPath: () => asNormalizedPath,
@@ -175376,6 +175377,32 @@ var TypingsInstaller = class {
     }
     this.processCacheLocation(this.globalCachePath);
   }
+  /** @internal */
+  handleRequest(req) {
+    switch (req.kind) {
+      case "discover":
+        this.install(req);
+        break;
+      case "closeProject":
+        this.closeProject(req);
+        break;
+      case "typesRegistry": {
+        const typesRegistry = {};
+        this.typesRegistry.forEach((value, key) => {
+          typesRegistry[key] = value;
+        });
+        const response = { kind: EventTypesRegistry, typesRegistry };
+        this.sendResponse(response);
+        break;
+      }
+      case "installPackage": {
+        this.installPackage(req);
+        break;
+      }
+      default:
+        Debug.assertNever(req);
+    }
+  }
   closeProject(req) {
     this.closeWatchers(req.projectName);
   }
@@ -176704,8 +176731,9 @@ var TypingsCache = class {
     return !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : typings;
   }
   onProjectClosed(project) {
-    this.perProjectCache.delete(project.getProjectName());
-    this.installer.onProjectClosed(project);
+    if (this.perProjectCache.delete(project.getProjectName())) {
+      this.installer.onProjectClosed(project);
+    }
   }
 };
 
@@ -186633,6 +186661,179 @@ var LineLeaf = class {
   }
 };
 
+// src/server/typingInstallerAdapter.ts
+var _TypingsInstallerAdapter = class _TypingsInstallerAdapter {
+  constructor(telemetryEnabled, logger, host, globalTypingsCacheLocation, event, maxActiveRequestCount) {
+    this.telemetryEnabled = telemetryEnabled;
+    this.logger = logger;
+    this.host = host;
+    this.globalTypingsCacheLocation = globalTypingsCacheLocation;
+    this.event = event;
+    this.maxActiveRequestCount = maxActiveRequestCount;
+    this.activeRequestCount = 0;
+    this.requestQueue = createQueue();
+    this.requestMap = /* @__PURE__ */ new Map();
+    // Maps project name to newest requestQueue entry for that project
+    /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
+    this.requestedRegistry = false;
+  }
+  isKnownTypesPackageName(name) {
+    var _a;
+    const validationResult = ts_JsTyping_exports.validatePackageName(name);
+    if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) {
+      return false;
+    }
+    if (!this.requestedRegistry) {
+      this.requestedRegistry = true;
+      this.installer.send({ kind: "typesRegistry" });
+    }
+    return !!((_a = this.typesRegistryCache) == null ? void 0 : _a.has(name));
+  }
+  installPackage(options) {
+    this.installer.send({ kind: "installPackage", ...options });
+    Debug.assert(this.packageInstalledPromise === void 0);
+    return new Promise((resolve, reject) => {
+      this.packageInstalledPromise = { resolve, reject };
+    });
+  }
+  attach(projectService) {
+    this.projectService = projectService;
+    this.installer = this.createInstallerProcess();
+  }
+  onProjectClosed(p) {
+    this.installer.send({ projectName: p.getProjectName(), kind: "closeProject" });
+  }
+  enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) {
+    const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
+    if (this.logger.hasLevel(3 /* verbose */)) {
+      this.logger.info(`TIAdapter:: Scheduling throttled operation:${stringifyIndented(request)}`);
+    }
+    if (this.activeRequestCount < this.maxActiveRequestCount) {
+      this.scheduleRequest(request);
+    } else {
+      if (this.logger.hasLevel(3 /* verbose */)) {
+        this.logger.info(`TIAdapter:: Deferring request for: ${request.projectName}`);
+      }
+      this.requestQueue.enqueue(request);
+      this.requestMap.set(request.projectName, request);
+    }
+  }
+  handleMessage(response) {
+    if (this.logger.hasLevel(3 /* verbose */)) {
+      this.logger.info(`TIAdapter:: Received response:${stringifyIndented(response)}`);
+    }
+    switch (response.kind) {
+      case EventTypesRegistry:
+        this.typesRegistryCache = new Map(Object.entries(response.typesRegistry));
+        break;
+      case ActionPackageInstalled: {
+        const { success, message } = response;
+        if (success) {
+          this.packageInstalledPromise.resolve({ successMessage: message });
+        } else {
+          this.packageInstalledPromise.reject(message);
+        }
+        this.packageInstalledPromise = void 0;
+        this.projectService.updateTypingsForProject(response);
+        this.event(response, "setTypings");
+        break;
+      }
+      case EventInitializationFailed: {
+        const body = {
+          message: response.message
+        };
+        const eventName = "typesInstallerInitializationFailed";
+        this.event(body, eventName);
+        break;
+      }
+      case EventBeginInstallTypes: {
+        const body = {
+          eventId: response.eventId,
+          packages: response.packagesToInstall
+        };
+        const eventName = "beginInstallTypes";
+        this.event(body, eventName);
+        break;
+      }
+      case EventEndInstallTypes: {
+        if (this.telemetryEnabled) {
+          const body2 = {
+            telemetryEventName: "typingsInstalled",
+            payload: {
+              installedPackages: response.packagesToInstall.join(","),
+              installSuccess: response.installSuccess,
+              typingsInstallerVersion: response.typingsInstallerVersion
+            }
+          };
+          const eventName2 = "telemetry";
+          this.event(body2, eventName2);
+        }
+        const body = {
+          eventId: response.eventId,
+          packages: response.packagesToInstall,
+          success: response.installSuccess
+        };
+        const eventName = "endInstallTypes";
+        this.event(body, eventName);
+        break;
+      }
+      case ActionInvalidate: {
+        this.projectService.updateTypingsForProject(response);
+        break;
+      }
+      case ActionSet: {
+        if (this.activeRequestCount > 0) {
+          this.activeRequestCount--;
+        } else {
+          Debug.fail("TIAdapter:: Received too many responses");
+        }
+        while (!this.requestQueue.isEmpty()) {
+          const queuedRequest = this.requestQueue.dequeue();
+          if (this.requestMap.get(queuedRequest.projectName) === queuedRequest) {
+            this.requestMap.delete(queuedRequest.projectName);
+            this.scheduleRequest(queuedRequest);
+            break;
+          }
+          if (this.logger.hasLevel(3 /* verbose */)) {
+            this.logger.info(`TIAdapter:: Skipping defunct request for: ${queuedRequest.projectName}`);
+          }
+        }
+        this.projectService.updateTypingsForProject(response);
+        this.event(response, "setTypings");
+        break;
+      }
+      case ActionWatchTypingLocations:
+        this.projectService.watchTypingLocations(response);
+        break;
+      default:
+        assertType(response);
+    }
+  }
+  scheduleRequest(request) {
+    if (this.logger.hasLevel(3 /* verbose */)) {
+      this.logger.info(`TIAdapter:: Scheduling request for: ${request.projectName}`);
+    }
+    this.activeRequestCount++;
+    this.host.setTimeout(
+      () => {
+        if (this.logger.hasLevel(3 /* verbose */)) {
+          this.logger.info(`TIAdapter:: Sending request:${stringifyIndented(request)}`);
+        }
+        this.installer.send(request);
+      },
+      _TypingsInstallerAdapter.requestDelayMillis,
+      `${request.projectName}::${request.kind}`
+    );
+  }
+};
+// This number is essentially arbitrary.  Processing more than one typings request
+// at a time makes sense, but having too many in the pipe results in a hang
+// (see https://github.com/nodejs/node/issues/7657).
+// It would be preferable to base our limit on the amount of space left in the
+// buffer, but we have yet to find a way to retrieve that value.
+_TypingsInstallerAdapter.requestDelayMillis = 100;
+var TypingsInstallerAdapter = _TypingsInstallerAdapter;
+
 // src/tsserver/_namespaces/ts.server.ts
 var ts_server_exports4 = {};
 __export(ts_server_exports4, {
@@ -186680,6 +186881,7 @@ __export(ts_server_exports4, {
   TextStorage: () => TextStorage,
   ThrottledOperations: () => ThrottledOperations,
   TypingsCache: () => TypingsCache,
+  TypingsInstallerAdapter: () => TypingsInstallerAdapter,
   allFilesAreJsOrDts: () => allFilesAreJsOrDts,
   allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
   asNormalizedPath: () => asNormalizedPath,
@@ -186799,7 +187001,7 @@ function initializeNodeSystem() {
   const sys2 = Debug.checkDefined(sys);
   const childProcess = require("child_process");
   const fs = require("fs");
-  class Logger6 {
+  class Logger7 {
     constructor(logFilename, traceToConsole, level) {
       this.logFilename = logFilename;
       this.traceToConsole = traceToConsole;
@@ -186866,7 +187068,7 @@ function initializeNodeSystem() {
       s = `[${nowString()}] ${s}
 `;
       if (!this.inGroup || this.firstInGroup) {
-        const prefix = Logger6.padStringRight(type + " " + this.seq.toString(), "          ");
+        const prefix = Logger7.padStringRight(type + " " + this.seq.toString(), "          ");
         s = prefix + s;
       }
       this.write(s, type);
@@ -187003,7 +187205,7 @@ function initializeNodeSystem() {
     const unsubstitutedLogFileName = cmdLineLogFileName ? stripQuotes(cmdLineLogFileName) : envLogOptions.logToFile ? envLogOptions.file || libDirectory + "/.log" + process.pid.toString() : void 0;
     const substitutedLogFileName = unsubstitutedLogFileName ? unsubstitutedLogFileName.replace("PID", process.pid.toString()) : void 0;
     const logVerbosity = cmdLineVerbosity || envLogOptions.detailLevel;
-    return new Logger6(substitutedLogFileName, envLogOptions.traceToConsole, logVerbosity);
+    return new Logger7(substitutedLogFileName, envLogOptions.traceToConsole, logVerbosity);
   }
   function writeMessage(buf) {
     if (!canWrite) {
@@ -187063,45 +187265,22 @@ function startNodeSession(options, logger, cancellationToken) {
     output: process.stdout,
     terminal: false
   });
-  const _NodeTypingsInstaller = class _NodeTypingsInstaller {
+  const _NodeTypingsInstallerAdapter = class _NodeTypingsInstallerAdapter extends TypingsInstallerAdapter {
     constructor(telemetryEnabled2, logger2, host, globalTypingsCacheLocation, typingSafeListLocation2, typesMapLocation2, npmLocation2, validateDefaultNpmLocation2, event) {
-      this.telemetryEnabled = telemetryEnabled2;
-      this.logger = logger2;
-      this.host = host;
-      this.globalTypingsCacheLocation = globalTypingsCacheLocation;
+      super(
+        telemetryEnabled2,
+        logger2,
+        host,
+        globalTypingsCacheLocation,
+        event,
+        _NodeTypingsInstallerAdapter.maxActiveRequestCount
+      );
       this.typingSafeListLocation = typingSafeListLocation2;
       this.typesMapLocation = typesMapLocation2;
       this.npmLocation = npmLocation2;
       this.validateDefaultNpmLocation = validateDefaultNpmLocation2;
-      this.event = event;
-      this.activeRequestCount = 0;
-      this.requestQueue = createQueue();
-      this.requestMap = /* @__PURE__ */ new Map();
-      // Maps operation ID to newest requestQueue entry with that ID
-      /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
-      this.requestedRegistry = false;
-    }
-    isKnownTypesPackageName(name) {
-      const validationResult = ts_JsTyping_exports.validatePackageName(name);
-      if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) {
-        return false;
-      }
-      if (this.requestedRegistry) {
-        return !!this.typesRegistryCache && this.typesRegistryCache.has(name);
-      }
-      this.requestedRegistry = true;
-      this.send({ kind: "typesRegistry" });
-      return false;
     }
-    installPackage(options2) {
-      this.send({ kind: "installPackage", ...options2 });
-      Debug.assert(this.packageInstalledPromise === void 0);
-      return new Promise((resolve, reject) => {
-        this.packageInstalledPromise = { resolve, reject };
-      });
-    }
-    attach(projectService) {
-      this.projectService = projectService;
+    createInstallerProcess() {
       if (this.logger.hasLevel(2 /* requestTime */)) {
         this.logger.info("Binding...");
       }
@@ -187140,135 +187319,7 @@ function startNodeSession(options, logger, cancellationToken) {
       process.on("exit", () => {
         this.installer.kill();
       });
-    }
-    onProjectClosed(p) {
-      this.send({ projectName: p.getProjectName(), kind: "closeProject" });
-    }
-    send(rq) {
-      this.installer.send(rq);
-    }
-    enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) {
-      const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
-      if (this.logger.hasLevel(3 /* verbose */)) {
-        if (this.logger.hasLevel(3 /* verbose */)) {
-          this.logger.info(`Scheduling throttled operation:${stringifyIndented(request)}`);
-        }
-      }
-      const operationId = project.getProjectName();
-      const operation = () => {
-        if (this.logger.hasLevel(3 /* verbose */)) {
-          this.logger.info(`Sending request:${stringifyIndented(request)}`);
-        }
-        this.send(request);
-      };
-      const queuedRequest = { operationId, operation };
-      if (this.activeRequestCount < _NodeTypingsInstaller.maxActiveRequestCount) {
-        this.scheduleRequest(queuedRequest);
-      } else {
-        if (this.logger.hasLevel(3 /* verbose */)) {
-          this.logger.info(`Deferring request for: ${operationId}`);
-        }
-        this.requestQueue.enqueue(queuedRequest);
-        this.requestMap.set(operationId, queuedRequest);
-      }
-    }
-    handleMessage(response) {
-      if (this.logger.hasLevel(3 /* verbose */)) {
-        this.logger.info(`Received response:${stringifyIndented(response)}`);
-      }
-      switch (response.kind) {
-        case EventTypesRegistry:
-          this.typesRegistryCache = new Map(Object.entries(response.typesRegistry));
-          break;
-        case ActionPackageInstalled: {
-          const { success, message } = response;
-          if (success) {
-            this.packageInstalledPromise.resolve({ successMessage: message });
-          } else {
-            this.packageInstalledPromise.reject(message);
-          }
-          this.packageInstalledPromise = void 0;
-          this.projectService.updateTypingsForProject(response);
-          this.event(response, "setTypings");
-          break;
-        }
-        case EventInitializationFailed: {
-          const body = {
-            message: response.message
-          };
-          const eventName = "typesInstallerInitializationFailed";
-          this.event(body, eventName);
-          break;
-        }
-        case EventBeginInstallTypes: {
-          const body = {
-            eventId: response.eventId,
-            packages: response.packagesToInstall
-          };
-          const eventName = "beginInstallTypes";
-          this.event(body, eventName);
-          break;
-        }
-        case EventEndInstallTypes: {
-          if (this.telemetryEnabled) {
-            const body2 = {
-              telemetryEventName: "typingsInstalled",
-              payload: {
-                installedPackages: response.packagesToInstall.join(","),
-                installSuccess: response.installSuccess,
-                typingsInstallerVersion: response.typingsInstallerVersion
-              }
-            };
-            const eventName2 = "telemetry";
-            this.event(body2, eventName2);
-          }
-          const body = {
-            eventId: response.eventId,
-            packages: response.packagesToInstall,
-            success: response.installSuccess
-          };
-          const eventName = "endInstallTypes";
-          this.event(body, eventName);
-          break;
-        }
-        case ActionInvalidate: {
-          this.projectService.updateTypingsForProject(response);
-          break;
-        }
-        case ActionSet: {
-          if (this.activeRequestCount > 0) {
-            this.activeRequestCount--;
-          } else {
-            Debug.fail("Received too many responses");
-          }
-          while (!this.requestQueue.isEmpty()) {
-            const queuedRequest = this.requestQueue.dequeue();
-            if (this.requestMap.get(queuedRequest.operationId) === queuedRequest) {
-              this.requestMap.delete(queuedRequest.operationId);
-              this.scheduleRequest(queuedRequest);
-              break;
-            }
-            if (this.logger.hasLevel(3 /* verbose */)) {
-              this.logger.info(`Skipping defunct request for: ${queuedRequest.operationId}`);
-            }
-          }
-          this.projectService.updateTypingsForProject(response);
-          this.event(response, "setTypings");
-          break;
-        }
-        case ActionWatchTypingLocations:
-          this.projectService.watchTypingLocations(response);
-          break;
-        default:
-          assertType(response);
-      }
-    }
-    scheduleRequest(request) {
-      if (this.logger.hasLevel(3 /* verbose */)) {
-        this.logger.info(`Scheduling request for: ${request.operationId}`);
-      }
-      this.activeRequestCount++;
-      this.host.setTimeout(request.operation, _NodeTypingsInstaller.requestDelayMillis);
+      return this.installer;
     }
   };
   // This number is essentially arbitrary.  Processing more than one typings request
@@ -187276,21 +187327,20 @@ function startNodeSession(options, logger, cancellationToken) {
   // (see https://github.com/nodejs/node/issues/7657).
   // It would be preferable to base our limit on the amount of space left in the
   // buffer, but we have yet to find a way to retrieve that value.
-  _NodeTypingsInstaller.maxActiveRequestCount = 10;
-  _NodeTypingsInstaller.requestDelayMillis = 100;
-  let NodeTypingsInstaller = _NodeTypingsInstaller;
+  _NodeTypingsInstallerAdapter.maxActiveRequestCount = 10;
+  let NodeTypingsInstallerAdapter = _NodeTypingsInstallerAdapter;
   class IOSession extends Session3 {
     constructor() {
       const event = (body, eventName) => {
         this.event(body, eventName);
       };
       const host = sys;
-      const typingsInstaller = disableAutomaticTypingAcquisition ? void 0 : new NodeTypingsInstaller(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, validateDefaultNpmLocation, event);
+      const typingsInstaller = disableAutomaticTypingAcquisition ? void 0 : new NodeTypingsInstallerAdapter(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, validateDefaultNpmLocation, event);
       super({
         host,
         cancellationToken,
         ...options,
-        typingsInstaller: typingsInstaller || nullTypingsInstaller,
+        typingsInstaller,
         byteLength: Buffer.byteLength,
         hrtime: process.hrtime,
         logger,

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231114`;
+      version = `${versionMajorMinor}.0-dev.20231115`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -172591,6 +172591,32 @@ ${options.prefix}` : "\n" : options.prefix
           }
           this.processCacheLocation(this.globalCachePath);
         }
+        /** @internal */
+        handleRequest(req) {
+          switch (req.kind) {
+            case "discover":
+              this.install(req);
+              break;
+            case "closeProject":
+              this.closeProject(req);
+              break;
+            case "typesRegistry": {
+              const typesRegistry = {};
+              this.typesRegistry.forEach((value, key) => {
+                typesRegistry[key] = value;
+              });
+              const response = { kind: EventTypesRegistry, typesRegistry };
+              this.sendResponse(response);
+              break;
+            }
+            case "installPackage": {
+              this.installPackage(req);
+              break;
+            }
+            default:
+              Debug.assertNever(req);
+          }
+        }
         closeProject(req) {
           this.closeWatchers(req.projectName);
         }
@@ -173989,8 +174015,9 @@ ${options.prefix}` : "\n" : options.prefix
           return !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : typings;
         }
         onProjectClosed(project) {
-          this.perProjectCache.delete(project.getProjectName());
-          this.installer.onProjectClosed(project);
+          if (this.perProjectCache.delete(project.getProjectName())) {
+            this.installer.onProjectClosed(project);
+          }
         }
       };
     }
@@ -183967,6 +183994,187 @@ ${e.message}`;
     }
   });
 
+  // src/server/typingInstallerAdapter.ts
+  var _TypingsInstallerAdapter, TypingsInstallerAdapter;
+  var init_typingInstallerAdapter = __esm({
+    "src/server/typingInstallerAdapter.ts"() {
+      "use strict";
+      init_ts7();
+      init_ts_server3();
+      _TypingsInstallerAdapter = class _TypingsInstallerAdapter {
+        constructor(telemetryEnabled, logger, host, globalTypingsCacheLocation, event, maxActiveRequestCount) {
+          this.telemetryEnabled = telemetryEnabled;
+          this.logger = logger;
+          this.host = host;
+          this.globalTypingsCacheLocation = globalTypingsCacheLocation;
+          this.event = event;
+          this.maxActiveRequestCount = maxActiveRequestCount;
+          this.activeRequestCount = 0;
+          this.requestQueue = createQueue();
+          this.requestMap = /* @__PURE__ */ new Map();
+          // Maps project name to newest requestQueue entry for that project
+          /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
+          this.requestedRegistry = false;
+        }
+        isKnownTypesPackageName(name) {
+          var _a;
+          const validationResult = ts_JsTyping_exports.validatePackageName(name);
+          if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) {
+            return false;
+          }
+          if (!this.requestedRegistry) {
+            this.requestedRegistry = true;
+            this.installer.send({ kind: "typesRegistry" });
+          }
+          return !!((_a = this.typesRegistryCache) == null ? void 0 : _a.has(name));
+        }
+        installPackage(options) {
+          this.installer.send({ kind: "installPackage", ...options });
+          Debug.assert(this.packageInstalledPromise === void 0);
+          return new Promise((resolve, reject) => {
+            this.packageInstalledPromise = { resolve, reject };
+          });
+        }
+        attach(projectService) {
+          this.projectService = projectService;
+          this.installer = this.createInstallerProcess();
+        }
+        onProjectClosed(p) {
+          this.installer.send({ projectName: p.getProjectName(), kind: "closeProject" });
+        }
+        enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) {
+          const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
+          if (this.logger.hasLevel(3 /* verbose */)) {
+            this.logger.info(`TIAdapter:: Scheduling throttled operation:${stringifyIndented(request)}`);
+          }
+          if (this.activeRequestCount < this.maxActiveRequestCount) {
+            this.scheduleRequest(request);
+          } else {
+            if (this.logger.hasLevel(3 /* verbose */)) {
+              this.logger.info(`TIAdapter:: Deferring request for: ${request.projectName}`);
+            }
+            this.requestQueue.enqueue(request);
+            this.requestMap.set(request.projectName, request);
+          }
+        }
+        handleMessage(response) {
+          if (this.logger.hasLevel(3 /* verbose */)) {
+            this.logger.info(`TIAdapter:: Received response:${stringifyIndented(response)}`);
+          }
+          switch (response.kind) {
+            case EventTypesRegistry:
+              this.typesRegistryCache = new Map(Object.entries(response.typesRegistry));
+              break;
+            case ActionPackageInstalled: {
+              const { success, message } = response;
+              if (success) {
+                this.packageInstalledPromise.resolve({ successMessage: message });
+              } else {
+                this.packageInstalledPromise.reject(message);
+              }
+              this.packageInstalledPromise = void 0;
+              this.projectService.updateTypingsForProject(response);
+              this.event(response, "setTypings");
+              break;
+            }
+            case EventInitializationFailed: {
+              const body = {
+                message: response.message
+              };
+              const eventName = "typesInstallerInitializationFailed";
+              this.event(body, eventName);
+              break;
+            }
+            case EventBeginInstallTypes: {
+              const body = {
+                eventId: response.eventId,
+                packages: response.packagesToInstall
+              };
+              const eventName = "beginInstallTypes";
+              this.event(body, eventName);
+              break;
+            }
+            case EventEndInstallTypes: {
+              if (this.telemetryEnabled) {
+                const body2 = {
+                  telemetryEventName: "typingsInstalled",
+                  payload: {
+                    installedPackages: response.packagesToInstall.join(","),
+                    installSuccess: response.installSuccess,
+                    typingsInstallerVersion: response.typingsInstallerVersion
+                  }
+                };
+                const eventName2 = "telemetry";
+                this.event(body2, eventName2);
+              }
+              const body = {
+                eventId: response.eventId,
+                packages: response.packagesToInstall,
+                success: response.installSuccess
+              };
+              const eventName = "endInstallTypes";
+              this.event(body, eventName);
+              break;
+            }
+            case ActionInvalidate: {
+              this.projectService.updateTypingsForProject(response);
+              break;
+            }
+            case ActionSet: {
+              if (this.activeRequestCount > 0) {
+                this.activeRequestCount--;
+              } else {
+                Debug.fail("TIAdapter:: Received too many responses");
+              }
+              while (!this.requestQueue.isEmpty()) {
+                const queuedRequest = this.requestQueue.dequeue();
+                if (this.requestMap.get(queuedRequest.projectName) === queuedRequest) {
+                  this.requestMap.delete(queuedRequest.projectName);
+                  this.scheduleRequest(queuedRequest);
+                  break;
+                }
+                if (this.logger.hasLevel(3 /* verbose */)) {
+                  this.logger.info(`TIAdapter:: Skipping defunct request for: ${queuedRequest.projectName}`);
+                }
+              }
+              this.projectService.updateTypingsForProject(response);
+              this.event(response, "setTypings");
+              break;
+            }
+            case ActionWatchTypingLocations:
+              this.projectService.watchTypingLocations(response);
+              break;
+            default:
+              assertType(response);
+          }
+        }
+        scheduleRequest(request) {
+          if (this.logger.hasLevel(3 /* verbose */)) {
+            this.logger.info(`TIAdapter:: Scheduling request for: ${request.projectName}`);
+          }
+          this.activeRequestCount++;
+          this.host.setTimeout(
+            () => {
+              if (this.logger.hasLevel(3 /* verbose */)) {
+                this.logger.info(`TIAdapter:: Sending request:${stringifyIndented(request)}`);
+              }
+              this.installer.send(request);
+            },
+            _TypingsInstallerAdapter.requestDelayMillis,
+            `${request.projectName}::${request.kind}`
+          );
+        }
+      };
+      // This number is essentially arbitrary.  Processing more than one typings request
+      // at a time makes sense, but having too many in the pipe results in a hang
+      // (see https://github.com/nodejs/node/issues/7657).
+      // It would be preferable to base our limit on the amount of space left in the
+      // buffer, but we have yet to find a way to retrieve that value.
+      _TypingsInstallerAdapter.requestDelayMillis = 100;
+      TypingsInstallerAdapter = _TypingsInstallerAdapter;
+    }
+  });
+
   // src/server/_namespaces/ts.server.ts
   var ts_server_exports3 = {};
   __export(ts_server_exports3, {
@@ -184014,6 +184222,7 @@ ${e.message}`;
     TextStorage: () => TextStorage,
     ThrottledOperations: () => ThrottledOperations,
     TypingsCache: () => TypingsCache,
+    TypingsInstallerAdapter: () => TypingsInstallerAdapter,
     allFilesAreJsOrDts: () => allFilesAreJsOrDts,
     allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
     asNormalizedPath: () => asNormalizedPath,
@@ -184082,6 +184291,7 @@ ${e.message}`;
       init_packageJsonCache();
       init_session();
       init_scriptVersionCache();
+      init_typingInstallerAdapter();
     }
   });
 
@@ -186436,6 +186646,7 @@ ${e.message}`;
     TextStorage: () => TextStorage,
     ThrottledOperations: () => ThrottledOperations,
     TypingsCache: () => TypingsCache,
+    TypingsInstallerAdapter: () => TypingsInstallerAdapter,
     allFilesAreJsOrDts: () => allFilesAreJsOrDts,
     allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
     asNormalizedPath: () => asNormalizedPath,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231114`;
+var version = `${versionMajorMinor}.0-dev.20231115`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -31850,6 +31850,32 @@ var TypingsInstaller = class {
     }
     this.processCacheLocation(this.globalCachePath);
   }
+  /** @internal */
+  handleRequest(req) {
+    switch (req.kind) {
+      case "discover":
+        this.install(req);
+        break;
+      case "closeProject":
+        this.closeProject(req);
+        break;
+      case "typesRegistry": {
+        const typesRegistry = {};
+        this.typesRegistry.forEach((value, key) => {
+          typesRegistry[key] = value;
+        });
+        const response = { kind: EventTypesRegistry, typesRegistry };
+        this.sendResponse(response);
+        break;
+      }
+      case "installPackage": {
+        this.installPackage(req);
+        break;
+      }
+      default:
+        Debug.assertNever(req);
+    }
+  }
   closeProject(req) {
     this.closeWatchers(req.projectName);
   }
@@ -32267,29 +32293,7 @@ var NodeTypingsInstaller = class extends TypingsInstaller {
       this.sendResponse(this.delayedInitializationError);
       this.delayedInitializationError = void 0;
     }
-    switch (req.kind) {
-      case "discover":
-        this.install(req);
-        break;
-      case "closeProject":
-        this.closeProject(req);
-        break;
-      case "typesRegistry": {
-        const typesRegistry = {};
-        this.typesRegistry.forEach((value, key) => {
-          typesRegistry[key] = value;
-        });
-        const response = { kind: EventTypesRegistry, typesRegistry };
-        this.sendResponse(response);
-        break;
-      }
-      case "installPackage": {
-        this.installPackage(req);
-        break;
-      }
-      default:
-        Debug.assertNever(req);
-    }
+    super.handleRequest(req);
   }
   sendResponse(response) {
     if (this.log.isEnabled()) {

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.4.0-dev.20231114",
+    "version": "5.4.0-dev.20231115",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -114,5 +114,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "b970fa4ae510c0e108670e497df967a05645a6a7"
+    "gitHead": "e170bc59d4ba0d335ce86f66296bec71c5018317"
 }