typescript-language-server 5.0.0 → 5.0.1

package/lib/cli.mjs

@@ -12990,6 +12990,28 @@ function requireStat() {
   return stat;
 }
 
+var async;
+
+var hasRequiredAsync;
+
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  async function asyncIteratorConcurrentProcess(iterator, fn) {
+    const promises = [];
+    for await (const item of iterator) {
+      promises.push(fn(item).then(() => null, err => err ?? new Error('unknown error')));
+    }
+    await Promise.all(promises.map(promise => promise.then(possibleErr => {
+      if (possibleErr !== null) throw possibleErr;
+    })));
+  }
+  async = {
+    asyncIteratorConcurrentProcess: asyncIteratorConcurrentProcess
+  };
+  return async;
+}
+
 var copy_1;
 
 var hasRequiredCopy$1;
@@ -13003,6 +13025,7 @@ function requireCopy$1() {
   const {pathExists: pathExists} = requirePathExists();
   const {utimesMillis: utimesMillis} = requireUtimes();
   const stat = requireStat();
+  const {asyncIteratorConcurrentProcess: asyncIteratorConcurrentProcess} = requireAsync();
   async function copy(src, dest, opts = {}) {
     if (typeof opts === 'function') {
       opts = {
@@ -13070,17 +13093,15 @@ function requireCopy$1() {
     if (!destStat) {
       await fs.mkdir(dest);
     }
-    const promises = [];
-    for await (const item of await fs.opendir(src)) {
+    await asyncIteratorConcurrentProcess(await fs.opendir(src), async item => {
       const srcItem = path.join(src, item.name);
       const destItem = path.join(dest, item.name);
-      promises.push(runFilter(srcItem, destItem, opts).then(include => {
-        if (include) {
-          return stat.checkPaths(srcItem, destItem, 'copy', opts).then(({destStat: destStat}) => getStatsAndPerformCopy(destStat, srcItem, destItem, opts));
-        }
-      }));
-    }
-    await Promise.all(promises);
+      const include = await runFilter(srcItem, destItem, opts);
+      if (include) {
+        const {destStat: destStat} = await stat.checkPaths(srcItem, destItem, 'copy', opts);
+        await getStatsAndPerformCopy(destStat, srcItem, destItem, opts);
+      }
+    });
     if (!destStat) {
       await fs.chmod(dest, srcStat.mode);
     }
@@ -18191,7 +18212,7 @@ class SingleTsServer {
   tryCancelRequest(seq, command) {
     try {
       if (this._requestQueue.tryDeletePendingRequest(seq)) {
-        this.logTrace(`Canceled request with sequence number ${seq}`);
+        this.logTrace(`Canceled pending request with sequence number ${seq}`);
         return true;
       }
       if (this._requestCanceller.tryCancelOngoingRequest(seq)) {
@@ -19305,7 +19326,8 @@ class TsClient {
       executions[0].catch(err => this.fatalError(command, err));
     }
     if (command === CommandTypes.UpdateOpen) {
-      Promise.all(executions).then(() => {
+      const executionsWithResults = executions.filter(e => e !== undefined);
+      Promise.all(executionsWithResults).then(() => {
         this.loadingIndicator.reset();
       });
     }
@@ -19375,30 +19397,73 @@ class TsClient {
   }
 }
 
-const pDebounce = (fn, wait, options = {}) => {
+const pDebounce = (function_, wait, options = {}) => {
   if (!Number.isFinite(wait)) {
     throw new TypeError('Expected `wait` to be a finite number');
   }
   let leadingValue;
   let timeout;
   let resolveList = [];
+  let rejectList = [];
+  const onAbort = () => {
+    clearTimeout(timeout);
+    timeout = null;
+    try {
+      options.signal?.throwIfAborted();
+    } catch (error) {
+      for (const reject of rejectList) {
+        reject(error);
+      }
+      resolveList = [];
+      rejectList = [];
+    }
+  };
   return function(...arguments_) {
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
+      try {
+        options.signal?.throwIfAborted();
+      } catch (error) {
+        reject(error);
+        return;
+      }
       const shouldCallNow = options.before && !timeout;
       clearTimeout(timeout);
-      timeout = setTimeout(() => {
+      timeout = setTimeout(async () => {
         timeout = null;
-        const result = options.before ? leadingValue : fn.apply(this, arguments_);
-        for (resolve of resolveList) {
-          resolve(result);
-        }
+        const currentResolveList = resolveList;
+        const currentRejectList = rejectList;
         resolveList = [];
+        rejectList = [];
+        try {
+          const result = options.before ? leadingValue : await function_.apply(this, arguments_);
+          for (const resolveFunction of currentResolveList) {
+            resolveFunction(result);
+          }
+        } catch (error) {
+          for (const rejectFunction of currentRejectList) {
+            rejectFunction(error);
+          }
+        }
+        leadingValue = undefined;
+        options.signal?.removeEventListener('abort', onAbort);
       }, wait);
       if (shouldCallNow) {
-        leadingValue = fn.apply(this, arguments_);
-        resolve(leadingValue);
+        (async () => {
+          try {
+            leadingValue = await function_.apply(this, arguments_);
+            resolve(leadingValue);
+          } catch (error) {
+            reject(error);
+          }
+        })();
       } else {
         resolveList.push(resolve);
+        rejectList.push(reject);
+        if (options.signal && resolveList.length === 1) {
+          options.signal.addEventListener('abort', onAbort, {
+            once: true
+          });
+        }
       }
     });
   };
@@ -19741,7 +19806,7 @@ class FileDiagnostics {
   }
 }
 
-class DiagnosticEventQueue {
+class DiagnosticsManager {
   constructor(publishDiagnostics, client, features, logger) {
     this.publishDiagnostics = publishDiagnostics;
     this.client = client;
@@ -19858,8 +19923,6 @@ class TSServerRequestCommand {
 TSServerRequestCommand.id = 'typescript.tsserverRequest';
 
 const Commands = {
-  APPLY_WORKSPACE_EDIT: '_typescript.applyWorkspaceEdit',
-  APPLY_CODE_ACTION: '_typescript.applyCodeAction',
   APPLY_REFACTORING: '_typescript.applyRefactoring',
   CONFIGURE_PLUGIN: '_typescript.configurePlugin',
   ORGANIZE_IMPORTS: '_typescript.organizeImports',
@@ -20682,19 +20745,6 @@ function toTsTriggerReason(context) {
   }
 }
 
-function provideQuickFix(response, client) {
-  if (!response?.body) {
-    return [];
-  }
-  return response.body.map(fix => mainExports$2.CodeAction.create(fix.description, {
-    title: fix.description,
-    command: Commands.APPLY_WORKSPACE_EDIT,
-    arguments: [ {
-      documentChanges: fix.changes.map(c => toTextDocumentEdit(c, client))
-    } ]
-  }, mainExports$2.CodeActionKind.QuickFix));
-}
-
 var CodeActionKind$1;
 
 (function(CodeActionKind) {
@@ -21440,187 +21490,6 @@ class FileConfigurationManager {
   }
 }
 
-const variableDeclaredButNeverUsed = new Set([ 6196, 6133 ]);
-
-const unreachableCode$1 = new Set([ 7027 ]);
-
-const incorrectlyImplementsInterface = new Set([ 2420 ]);
-
-const cannotFindName = new Set([ 2552, 2304 ]);
-
-const asyncOnlyAllowedInAsyncFunctions = new Set([ 1308 ]);
-
-const awaitInSyncFunction = 'fixAwaitInSyncFunction';
-
-const classIncorrectlyImplementsInterface = 'fixClassIncorrectlyImplementsInterface';
-
-const unreachableCode = 'fixUnreachableCode';
-
-const unusedIdentifier = 'unusedIdentifier';
-
-const fixImport = 'import';
-
-async function buildIndividualFixes(fixes, client, file, diagnostics) {
-  const edits = [];
-  for (const diagnostic of diagnostics) {
-    for (const {codes: codes, fixName: fixName} of fixes) {
-      if (!codes.has(diagnostic.code)) {
-        continue;
-      }
-      const args = {
-        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
-        errorCodes: [ +diagnostic.code ]
-      };
-      const response = await client.execute(CommandTypes.GetCodeFixes, args);
-      if (response.type !== 'response') {
-        continue;
-      }
-      const fix = response.body?.find(fix => fix.fixName === fixName);
-      if (fix) {
-        edits.push(...fix.changes.map(change => toTextDocumentEdit(change, client)));
-        break;
-      }
-    }
-  }
-  return edits;
-}
-
-async function buildCombinedFix(fixes, client, file, diagnostics) {
-  const edits = [];
-  for (const diagnostic of diagnostics) {
-    for (const {codes: codes, fixName: fixName} of fixes) {
-      if (!codes.has(diagnostic.code)) {
-        continue;
-      }
-      const args = {
-        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
-        errorCodes: [ +diagnostic.code ]
-      };
-      const response = await client.execute(CommandTypes.GetCodeFixes, args);
-      if (response.type !== 'response' || !response.body?.length) {
-        continue;
-      }
-      const fix = response.body?.find(fix => fix.fixName === fixName);
-      if (!fix) {
-        continue;
-      }
-      if (!fix.fixId) {
-        edits.push(...fix.changes.map(change => toTextDocumentEdit(change, client)));
-        return edits;
-      }
-      const combinedArgs = {
-        scope: {
-          type: 'file',
-          args: {
-            file: file
-          }
-        },
-        fixId: fix.fixId
-      };
-      const combinedResponse = await client.execute(CommandTypes.GetCombinedCodeFix, combinedArgs);
-      if (combinedResponse.type !== 'response' || !combinedResponse.body) {
-        return edits;
-      }
-      edits.push(...combinedResponse.body.changes.map(change => toTextDocumentEdit(change, client)));
-      return edits;
-    }
-  }
-  return edits;
-}
-
-class SourceAction {}
-
-class SourceFixAll extends SourceAction {
-  constructor() {
-    super(...arguments);
-    this.title = 'Fix all';
-  }
-  async build(client, file, diagnostics) {
-    const edits = [];
-    edits.push(...await buildIndividualFixes([ {
-      codes: incorrectlyImplementsInterface,
-      fixName: classIncorrectlyImplementsInterface
-    }, {
-      codes: asyncOnlyAllowedInAsyncFunctions,
-      fixName: awaitInSyncFunction
-    } ], client, file, diagnostics));
-    edits.push(...await buildCombinedFix([ {
-      codes: unreachableCode$1,
-      fixName: unreachableCode
-    } ], client, file, diagnostics));
-    if (!edits.length) {
-      return null;
-    }
-    return mainExports$2.CodeAction.create(this.title, {
-      documentChanges: edits
-    }, SourceFixAll.kind.value);
-  }
-}
-
-SourceFixAll.kind = CodeActionKind.SourceFixAllTs;
-
-class SourceRemoveUnused extends SourceAction {
-  constructor() {
-    super(...arguments);
-    this.title = 'Remove all unused code';
-  }
-  async build(client, file, diagnostics) {
-    const edits = await buildCombinedFix([ {
-      codes: variableDeclaredButNeverUsed,
-      fixName: unusedIdentifier
-    } ], client, file, diagnostics);
-    if (!edits.length) {
-      return null;
-    }
-    return mainExports$2.CodeAction.create(this.title, {
-      documentChanges: edits
-    }, SourceRemoveUnused.kind.value);
-  }
-}
-
-SourceRemoveUnused.kind = CodeActionKind.SourceRemoveUnusedTs;
-
-class SourceAddMissingImports extends SourceAction {
-  constructor() {
-    super(...arguments);
-    this.title = 'Add all missing imports';
-  }
-  async build(client, file, diagnostics) {
-    const edits = await buildCombinedFix([ {
-      codes: cannotFindName,
-      fixName: fixImport
-    } ], client, file, diagnostics);
-    if (!edits.length) {
-      return null;
-    }
-    return mainExports$2.CodeAction.create(this.title, {
-      documentChanges: edits
-    }, SourceAddMissingImports.kind.value);
-  }
-}
-
-SourceAddMissingImports.kind = CodeActionKind.SourceAddMissingImportsTs;
-
-class TypeScriptAutoFixProvider {
-  static get kinds() {
-    return TypeScriptAutoFixProvider.kindProviders.map(provider => provider.kind);
-  }
-  constructor(client) {
-    this.client = client;
-  }
-  async provideCodeActions(kinds, file, diagnostics) {
-    const results = [];
-    for (const provider of TypeScriptAutoFixProvider.kindProviders) {
-      if (kinds.some(kind => kind.contains(provider.kind))) {
-        results.push((new provider).build(this.client, file, diagnostics));
-      }
-    }
-    return (await Promise.all(results)).flatMap(result => result || []);
-  }
-}
-
-TypeScriptAutoFixProvider.kindProviders = [ SourceFixAll, SourceRemoveUnused, SourceAddMissingImports ];
-
 function escapeRegExp(text) {
   return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 }
@@ -22465,60 +22334,783 @@ class TypeScriptVersionProvider {
   }
 }
 
-class LspServer {
-  constructor(options) {
-    this.options = options;
-    this.initializeParams = null;
-    this.completionDataCache = new CompletionDataCache;
-    this.typeScriptAutoFixProvider = null;
-    this.features = {};
-    this.cachedNavTreeResponse = new CachedResponse;
-    this.implementationsCodeLensProvider = null;
-    this.referencesCodeLensProvider = null;
-    this.logger = new PrefixingLogger(options.logger, '[lspserver]');
-    this.tsClient = new TsClient(onCaseInsensitiveFileSystem(), this.logger, options.lspClient);
-    this.fileConfigurationManager = new FileConfigurationManager(this.tsClient, onCaseInsensitiveFileSystem());
-    this.diagnosticQueue = new DiagnosticEventQueue(diagnostics => this.options.lspClient.publishDiagnostics(diagnostics), this.tsClient, this.features, this.logger);
+class CommandManager {
+  constructor() {
+    this.commands = new Map;
   }
-  closeAllForTesting() {
-    for (const document of this.tsClient.documentsForTesting.values()) {
-      this.closeDocument(document.uri.toString());
+  dispose() {
+    this.commands.clear();
+  }
+  register(command) {
+    const entry = this.commands.get(command.id);
+    if (!entry) {
+      this.commands.set(command.id, command);
     }
   }
-  async waitForDiagnosticsForFile(uri) {
-    const document = this.tsClient.toOpenDocument(uri);
-    if (!document) {
-      throw new Error(`Document not open: ${uri}`);
+  async handle(commandId, ...args) {
+    const entry = this.commands.get(commandId);
+    if (entry) {
+      await entry.execute(...args);
+      return true;
     }
-    await this.diagnosticQueue.waitForDiagnosticsForTesting(document.filepath);
+    return false;
   }
-  shutdown() {
-    this.tsClient.shutdown();
+}
+
+const variableDeclaredButNeverUsed = new Set([ 6196, 6133 ]);
+
+const unreachableCode$1 = new Set([ 7027 ]);
+
+const incorrectlyImplementsInterface = new Set([ 2420 ]);
+
+const cannotFindName = new Set([ 2552, 2304 ]);
+
+const asyncOnlyAllowedInAsyncFunctions = new Set([ 1308 ]);
+
+const addMissingAwait = 'addMissingAwait';
+
+const addMissingNewOperator = 'addMissingNewOperator';
+
+const addMissingOverride = 'fixOverrideModifier';
+
+const annotateWithTypeFromJSDoc = 'annotateWithTypeFromJSDoc';
+
+const awaitInSyncFunction = 'fixAwaitInSyncFunction';
+
+const classDoesntImplementInheritedAbstractMember = 'fixClassDoesntImplementInheritedAbstractMember';
+
+const classIncorrectlyImplementsInterface = 'fixClassIncorrectlyImplementsInterface';
+
+const constructorForDerivedNeedSuperCall = 'constructorForDerivedNeedSuperCall';
+
+const extendsInterfaceBecomesImplements = 'extendsInterfaceBecomesImplements';
+
+const fixImport = 'import';
+
+const forgottenThisPropertyAccess = 'forgottenThisPropertyAccess';
+
+const removeUnnecessaryAwait = 'removeUnnecessaryAwait';
+
+const spelling = 'spelling';
+
+const unreachableCode = 'fixUnreachableCode';
+
+const unusedIdentifier = 'unusedIdentifier';
+
+class TsCodeAction {
+  constructor(title, kind) {
+    this.title = title;
+    this.kind = kind;
   }
-  initialize(params) {
-    this.initializeParams = params;
-    const clientCapabilities = this.initializeParams.capabilities;
-    this.workspaceRoot = this.initializeParams.rootUri ? URI.parse(this.initializeParams.rootUri).fsPath : this.initializeParams.rootPath || undefined;
-    const userInitializationOptions = this.initializeParams.initializationOptions || {};
-    const {disableAutomaticTypingAcquisition: disableAutomaticTypingAcquisition, hostInfo: hostInfo, maxTsServerMemory: maxTsServerMemory, npmLocation: npmLocation, locale: locale, plugins: plugins, tsserver: tsserver} = userInitializationOptions;
-    const typescriptVersion = this.findTypescriptVersion(tsserver?.path, tsserver?.fallbackPath);
-    if (typescriptVersion) {
-      this.options.lspClient.logMessage({
-        type: mainExports$2.MessageType.Info,
-        message: `Using Typescript version (${typescriptVersion.source}) ${typescriptVersion.versionString} from path "${typescriptVersion.tsServerPath}"`
-      });
-    } else {
-      throw Error('Could not find a valid TypeScript installation. Please ensure that the "typescript" dependency is installed in the workspace or that a valid `tsserver.path` is specified. Exiting.');
+  toLspCodeAction() {
+    const codeAction = mainExports$2.CodeAction.create(this.title, this.kind);
+    if (this.command !== undefined) {
+      codeAction.command = this.command;
     }
-    this.fileConfigurationManager.mergeTsPreferences(userInitializationOptions.preferences || {});
-    this.features.completionDisableFilterText = userInitializationOptions.completionDisableFilterText ?? false;
-    this.features.moveToFileCodeActionSupport = userInitializationOptions.supportsMoveToFileCodeAction && typescriptVersion.version?.gte(API.v520);
-    const {textDocument: textDocument} = clientCapabilities;
-    if (textDocument) {
-      const {codeAction: codeAction, completion: completion, definition: definition, publishDiagnostics: publishDiagnostics} = textDocument;
-      if (codeAction) {
-        this.features.codeActionDisabledSupport = codeAction.disabledSupport;
-      }
+    if (this.diagnostics !== undefined) {
+      codeAction.diagnostics = this.diagnostics;
+    }
+    if (this.disabled !== undefined) {
+      codeAction.disabled = this.disabled;
+    }
+    if (this.edit !== undefined) {
+      codeAction.edit = this.edit;
+    }
+    if (this.isPreferred !== undefined) {
+      codeAction.isPreferred = this.isPreferred;
+    }
+    return codeAction;
+  }
+}
+
+async function buildIndividualFixes(fixes, client, file, diagnostics, token) {
+  const documentChanges = [];
+  for (const diagnostic of diagnostics) {
+    for (const {codes: codes, fixName: fixName} of fixes) {
+      if (token.isCancellationRequested) {
+        return;
+      }
+      if (!codes.has(diagnostic.code)) {
+        continue;
+      }
+      const args = {
+        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
+        errorCodes: [ +diagnostic.code ]
+      };
+      const response = await client.execute(CommandTypes.GetCodeFixes, args, token);
+      if (response.type !== 'response') {
+        continue;
+      }
+      const fix = response.body?.find(fix => fix.fixName === fixName);
+      if (fix) {
+        documentChanges.push(...fix.changes.map(change => toTextDocumentEdit(change, client)));
+        break;
+      }
+    }
+  }
+  return {
+    documentChanges: documentChanges
+  };
+}
+
+async function buildCombinedFix(fixes, client, file, diagnostics, token) {
+  for (const diagnostic of diagnostics) {
+    for (const {codes: codes, fixName: fixName} of fixes) {
+      if (token.isCancellationRequested) {
+        return;
+      }
+      if (!codes.has(diagnostic.code)) {
+        continue;
+      }
+      const args = {
+        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
+        errorCodes: [ +diagnostic.code ]
+      };
+      const response = await client.execute(CommandTypes.GetCodeFixes, args, token);
+      if (response.type !== 'response' || !response.body?.length) {
+        continue;
+      }
+      const fix = response.body?.find(fix => fix.fixName === fixName);
+      if (!fix) {
+        continue;
+      }
+      if (!fix.fixId) {
+        return {
+          documentChanges: fix.changes.map(change => toTextDocumentEdit(change, client))
+        };
+      }
+      const combinedArgs = {
+        scope: {
+          type: 'file',
+          args: {
+            file: file
+          }
+        },
+        fixId: fix.fixId
+      };
+      const combinedResponse = await client.execute(CommandTypes.GetCombinedCodeFix, combinedArgs, token);
+      if (combinedResponse.type !== 'response' || !combinedResponse.body) {
+        return;
+      }
+      return {
+        documentChanges: combinedResponse.body.changes.map(change => toTextDocumentEdit(change, client))
+      };
+    }
+  }
+}
+
+class SourceAction extends TsCodeAction {}
+
+class SourceFixAll extends SourceAction {
+  constructor() {
+    super('Fix all fixable JS/TS issues', SourceFixAll.kind.value);
+  }
+  async build(client, file, diagnostics, token) {
+    this.edit = await buildIndividualFixes([ {
+      codes: incorrectlyImplementsInterface,
+      fixName: classIncorrectlyImplementsInterface
+    }, {
+      codes: asyncOnlyAllowedInAsyncFunctions,
+      fixName: awaitInSyncFunction
+    } ], client, file, diagnostics, token);
+    const edits = await buildCombinedFix([ {
+      codes: unreachableCode$1,
+      fixName: unreachableCode
+    } ], client, file, diagnostics, token);
+    if (edits?.documentChanges) {
+      this.edit?.documentChanges?.push(...edits.documentChanges);
+    }
+  }
+}
+
+SourceFixAll.kind = CodeActionKind.SourceFixAllTs;
+
+class SourceRemoveUnused extends SourceAction {
+  constructor() {
+    super('Remove all unused code', SourceRemoveUnused.kind.value);
+  }
+  async build(client, file, diagnostics, token) {
+    this.edit = await buildCombinedFix([ {
+      codes: variableDeclaredButNeverUsed,
+      fixName: unusedIdentifier
+    } ], client, file, diagnostics, token);
+  }
+}
+
+SourceRemoveUnused.kind = CodeActionKind.SourceRemoveUnusedTs;
+
+class SourceAddMissingImports extends SourceAction {
+  constructor() {
+    super('Add all missing imports', SourceAddMissingImports.kind.value);
+  }
+  async build(client, file, diagnostics, token) {
+    this.edit = await buildCombinedFix([ {
+      codes: cannotFindName,
+      fixName: fixImport
+    } ], client, file, diagnostics, token);
+  }
+}
+
+SourceAddMissingImports.kind = CodeActionKind.SourceAddMissingImportsTs;
+
+class TypeScriptAutoFixProvider {
+  constructor(client, fileConfigurationManager, diagnosticsManager) {
+    this.client = client;
+    this.fileConfigurationManager = fileConfigurationManager;
+    this.diagnosticsManager = diagnosticsManager;
+  }
+  getMetadata() {
+    return {
+      providedCodeActionKinds: TypeScriptAutoFixProvider.kindProviders.map(x => x.kind.value)
+    };
+  }
+  async provideCodeActions(document, _range, context, token) {
+    if (!context.only?.length) {
+      return undefined;
+    }
+    const sourceKinds = context.only.map(kind => new CodeActionKind(kind)).filter(codeActionKind => CodeActionKind.Source.intersects(codeActionKind));
+    if (!sourceKinds.length) {
+      return undefined;
+    }
+    if (this.client.hasPendingDiagnostics(document.uri)) {
+      return undefined;
+    }
+    const actions = this.getFixAllActions(sourceKinds);
+    const diagnostics = this.diagnosticsManager.getDiagnosticsForFile(document.filepath);
+    if (!diagnostics.length) {
+      return actions;
+    }
+    await this.fileConfigurationManager.ensureConfigurationForDocument(document, token);
+    if (token.isCancellationRequested) {
+      return undefined;
+    }
+    await Promise.all(actions.map(action => action.build(this.client, document.filepath, diagnostics, token)));
+    return actions;
+  }
+  isCodeActionResolvable(_codeAction) {
+    return false;
+  }
+  getFixAllActions(kinds) {
+    return TypeScriptAutoFixProvider.kindProviders.filter(provider => kinds.some(only => only.intersects(provider.kind))).map(provider => new provider);
+  }
+}
+
+TypeScriptAutoFixProvider.kindProviders = [ SourceFixAll, SourceRemoveUnused, SourceAddMissingImports ];
+
+class Lazy {
+  constructor(executor) {
+    this.executor = executor;
+    this._didRun = false;
+  }
+  get hasValue() {
+    return this._didRun;
+  }
+  get value() {
+    if (!this._didRun) {
+      try {
+        this._value = this.executor();
+      } catch (err) {
+        this._error = err;
+      } finally {
+        this._didRun = true;
+      }
+    }
+    if (this._error) {
+      throw this._error;
+    }
+    return this._value;
+  }
+  get rawValue() {
+    return this._value;
+  }
+}
+
+function getEditForCodeAction(client, action) {
+  return action.changes?.length ? {
+    documentChanges: action.changes.map(change => toTextDocumentEdit(change, client))
+  } : undefined;
+}
+
+async function applyCodeActionCommands(client, commands, token) {
+  if (commands?.length) {
+    for (const command of commands) {
+      await client.execute(CommandTypes.ApplyCodeActionCommand, {
+        command: command
+      }, token);
+    }
+  }
+  return true;
+}
+
+class ApplyCodeActionCommand {
+  constructor(client) {
+    this.client = client;
+    this.id = ApplyCodeActionCommand.ID;
+  }
+  async execute({action: action}) {
+    const codeActionResult = await applyCodeActionCommands(this.client, action.commands);
+    return codeActionResult;
+  }
+}
+
+ApplyCodeActionCommand.ID = '_typescript.applyCodeActionCommand';
+
+class ApplyFixAllCodeAction {
+  constructor(client, tsCodeActionProvider) {
+    this.client = client;
+    this.tsCodeActionProvider = tsCodeActionProvider;
+    this.id = ApplyFixAllCodeAction.ID;
+  }
+  async execute(args) {
+    const tsAction = this.tsCodeActionProvider.getQuickFixAllTsCodeActionByFixName(args.tsActionId);
+    if (tsAction instanceof TsQuickFixAllCodeAction && tsAction.combinedResponse) {
+      await applyCodeActionCommands(this.client, tsAction.combinedResponse.body.commands);
+    }
+  }
+}
+
+ApplyFixAllCodeAction.ID = '_typescript.applyFixAllCodeAction';
+
+class DiagnosticsSet {
+  static from(diagnostics) {
+    const values = new Map;
+    for (const diagnostic of diagnostics) {
+      values.set(DiagnosticsSet.key(diagnostic), diagnostic);
+    }
+    return new DiagnosticsSet(values);
+  }
+  static key(diagnostic) {
+    const {start: start, end: end} = diagnostic.range;
+    return `${diagnostic.code}-${start.line},${start.character}-${end.line},${end.character}`;
+  }
+  constructor(_values) {
+    this._values = _values;
+  }
+  get values() {
+    return this._values.values();
+  }
+  get size() {
+    return this._values.size;
+  }
+}
+
+class TsQuickFixCodeAction extends TsCodeAction {
+  constructor(tsAction, title, kind) {
+    super(title, kind);
+    this.tsAction = tsAction;
+  }
+}
+
+class TsQuickFixAllCodeAction extends TsQuickFixCodeAction {
+  constructor(tsAction, file, title, kind) {
+    super(tsAction, title, kind);
+    this.file = file;
+  }
+}
+
+class CodeActionSet {
+  constructor() {
+    this._actions = new Set;
+    this._fixAllActions = new Map;
+    this._aiActions = new Set;
+  }
+  * values() {
+    yield* this._actions;
+    yield* this._aiActions;
+  }
+  addAction(action) {
+    for (const existing of this._actions) {
+      if (action.tsAction.fixName === existing.tsAction.fixName && equals(action.edit, existing.edit)) {
+        this._actions.delete(existing);
+      }
+    }
+    this._actions.add(action);
+    if (action.tsAction.fixId) {
+      const existingFixAll = this._fixAllActions.get(action.tsAction.fixId);
+      if (existingFixAll) {
+        this._actions.delete(existingFixAll);
+        this._actions.add(existingFixAll);
+      }
+    }
+  }
+  addFixAllAction(fixId, action) {
+    const existing = this._fixAllActions.get(fixId);
+    if (existing) {
+      this._actions.delete(existing);
+    }
+    this.addAction(action);
+    this._fixAllActions.set(fixId, action);
+  }
+  hasFixAllAction(fixId) {
+    return this._fixAllActions.has(fixId);
+  }
+}
+
+class SupportedCodeActionProvider {
+  constructor(client) {
+    this.client = client;
+    this.fixableDiagnosticCodes = new Lazy(() => this.client.execute(CommandTypes.GetSupportedCodeFixes, null).then(response => response.type === 'response' ? response.body || [] : []).then(codes => new Set(codes)));
+  }
+  async getFixableDiagnosticsForContext(diagnostics) {
+    const fixableCodes = await this.fixableDiagnosticCodes.value;
+    return DiagnosticsSet.from(diagnostics.filter(diagnostic => typeof diagnostic.code !== 'undefined' && fixableCodes.has(diagnostic.code + '')));
+  }
+}
+
+class TypeScriptQuickFixProvider {
+  constructor(client, fileConfigurationManager, commandManager, diagnosticsManager, features) {
+    this.client = client;
+    this.fileConfigurationManager = fileConfigurationManager;
+    this.diagnosticsManager = diagnosticsManager;
+    this.features = features;
+    this._quickFixAllTsCodeActionMap = new Map;
+    commandManager.register(new ApplyCodeActionCommand(client));
+    commandManager.register(new ApplyFixAllCodeAction(client, this));
+    this.supportedCodeActionProvider = new SupportedCodeActionProvider(client);
+  }
+  getMetadata() {
+    return {
+      providedCodeActionKinds: [ CodeActionKind.QuickFix.value ]
+    };
+  }
+  async provideCodeActions(document, range, context, token) {
+    this._quickFixAllTsCodeActionMap.clear();
+    let diagnostics = context.diagnostics;
+    if (this.client.hasPendingDiagnostics(document.uri)) {
+      await new Promise(resolve => {
+        setTimeout(resolve, 500);
+      });
+      if (token.isCancellationRequested) {
+        return;
+      }
+      const allDiagnostics = [];
+      for (const diagnostic of this.diagnosticsManager.getDiagnosticsForFile(document.filepath)) {
+        if (Range.intersection(range, diagnostic.range)) {
+          const newLen = allDiagnostics.push(diagnostic);
+          if (newLen > TypeScriptQuickFixProvider._maxCodeActionsPerFile) {
+            break;
+          }
+        }
+      }
+      diagnostics = allDiagnostics;
+    }
+    const fixableDiagnostics = await this.supportedCodeActionProvider.getFixableDiagnosticsForContext(diagnostics);
+    if (!fixableDiagnostics.size || token.isCancellationRequested) {
+      return;
+    }
+    await this.fileConfigurationManager.ensureConfigurationForDocument(document, token);
+    if (token.isCancellationRequested) {
+      return;
+    }
+    const results = new CodeActionSet;
+    for (const diagnostic of fixableDiagnostics.values) {
+      await this.getFixesForDiagnostic(document, diagnostic, results, token);
+      if (token.isCancellationRequested) {
+        return;
+      }
+    }
+    const allActions = Array.from(results.values());
+    for (const action of allActions) {
+      action.isPreferred = isPreferredFix(action, allActions);
+    }
+    return allActions;
+  }
+  isCodeActionResolvable(codeAction) {
+    return codeAction instanceof TsQuickFixAllCodeAction;
+  }
+  async resolveCodeAction(codeAction, token) {
+    if (!this.isCodeActionResolvable(codeAction) || !codeAction.tsAction.fixId) {
+      return codeAction;
+    }
+    const arg = {
+      scope: {
+        type: 'file',
+        args: {
+          file: codeAction.file
+        }
+      },
+      fixId: codeAction.tsAction.fixId
+    };
+    const response = await this.client.execute(CommandTypes.GetCombinedCodeFix, arg, token);
+    if (response.type === 'response') {
+      codeAction.combinedResponse = response;
+      codeAction.edit = {
+        documentChanges: response.body.changes.map(change => toTextDocumentEdit(change, this.client))
+      };
+    }
+    return codeAction;
+  }
+  getQuickFixAllTsCodeActionByFixName(fixName) {
+    return this._quickFixAllTsCodeActionMap.get(fixName);
+  }
+  async getFixesForDiagnostic(document, diagnostic, results, token) {
+    const args = {
+      ...Range.toFileRangeRequestArgs(document.filepath, diagnostic.range),
+      errorCodes: [ +diagnostic.code ]
+    };
+    const response = await this.client.execute(CommandTypes.GetCodeFixes, args, token);
+    if (response.type !== 'response' || !response.body) {
+      return results;
+    }
+    for (const tsCodeFix of response.body) {
+      for (const action of this.getFixesForTsCodeAction(document, diagnostic, tsCodeFix)) {
+        results.addAction(action);
+      }
+      if (this.features.codeActionResolveSupport) {
+        this.addFixAllForTsCodeAction(results, document.uri, document.filepath, diagnostic, tsCodeFix);
+      }
+    }
+    return results;
+  }
+  getFixesForTsCodeAction(document, diagnostic, action) {
+    const actions = [];
+    const codeAction = new TsQuickFixCodeAction(action, action.description, mainExports$2.CodeActionKind.QuickFix);
+    codeAction.edit = getEditForCodeAction(this.client, action);
+    codeAction.diagnostics = [ diagnostic ];
+    codeAction.command = {
+      command: ApplyCodeActionCommand.ID,
+      arguments: [ {
+        action: action,
+        diagnostic: diagnostic,
+        documentUri: document.uri.toString()
+      } ],
+      title: ''
+    };
+    actions.push(codeAction);
+    return actions;
+  }
+  addFixAllForTsCodeAction(results, _resource, file, diagnostic, tsAction) {
+    if (!tsAction.fixId || results.hasFixAllAction(tsAction.fixId)) {
+      return results;
+    }
+    if (!this.diagnosticsManager.getDiagnosticsForFile(file).some(x => {
+      if (x === diagnostic) {
+        return false;
+      }
+      return x.code === diagnostic.code || fixAllErrorCodes.has(x.code) && fixAllErrorCodes.get(x.code) === fixAllErrorCodes.get(diagnostic.code);
+    })) {
+      return results;
+    }
+    const action = new TsQuickFixAllCodeAction(tsAction, file, tsAction.fixAllDescription || `${tsAction.description} (Fix all in file)`, mainExports$2.CodeActionKind.QuickFix);
+    action.diagnostics = [ diagnostic ];
+    action.command = {
+      command: ApplyFixAllCodeAction.ID,
+      arguments: [ {
+        tsActionId: tsAction.fixName
+      } ],
+      title: ''
+    };
+    this._quickFixAllTsCodeActionMap.set(tsAction.fixName, action);
+    results.addFixAllAction(tsAction.fixId, action);
+    return results;
+  }
+}
+
+TypeScriptQuickFixProvider._maxCodeActionsPerFile = 1e3;
+
+const fixAllErrorCodes = new Map([ [ 2339, 2339 ], [ 2345, 2339 ] ]);
+
+const preferredFixes = new Map([ [ annotateWithTypeFromJSDoc, {
+  priority: 2
+} ], [ constructorForDerivedNeedSuperCall, {
+  priority: 2
+} ], [ extendsInterfaceBecomesImplements, {
+  priority: 2
+} ], [ awaitInSyncFunction, {
+  priority: 2
+} ], [ removeUnnecessaryAwait, {
+  priority: 2
+} ], [ classIncorrectlyImplementsInterface, {
+  priority: 3
+} ], [ classDoesntImplementInheritedAbstractMember, {
+  priority: 3
+} ], [ unreachableCode, {
+  priority: 2
+} ], [ unusedIdentifier, {
+  priority: 2
+} ], [ forgottenThisPropertyAccess, {
+  priority: 2
+} ], [ spelling, {
+  priority: 0
+} ], [ addMissingAwait, {
+  priority: 2
+} ], [ addMissingOverride, {
+  priority: 2
+} ], [ addMissingNewOperator, {
+  priority: 2
+} ], [ fixImport, {
+  priority: 1,
+  thereCanOnlyBeOne: true
+} ] ]);
+
+function isPreferredFix(action, allActions) {
+  if (action instanceof TsQuickFixAllCodeAction) {
+    return false;
+  }
+  const fixPriority = preferredFixes.get(action.tsAction.fixName);
+  if (!fixPriority) {
+    return false;
+  }
+  return allActions.every(otherAction => {
+    if (otherAction === action) {
+      return true;
+    }
+    if (otherAction instanceof TsQuickFixAllCodeAction) {
+      return true;
+    }
+    const otherFixPriority = preferredFixes.get(otherAction.tsAction.fixName);
+    if (!otherFixPriority || otherFixPriority.priority < fixPriority.priority) {
+      return true;
+    } else if (otherFixPriority.priority > fixPriority.priority) {
+      return false;
+    }
+    if (fixPriority.thereCanOnlyBeOne && action.tsAction.fixName === otherAction.tsAction.fixName) {
+      return false;
+    }
+    return true;
+  });
+}
+
+const noopDisposable = mainExports$2.Disposable.create(() => {});
+
+const nulToken = {
+  isCancellationRequested: false,
+  onCancellationRequested: () => noopDisposable
+};
+
+class CodeActionManager {
+  constructor(client, fileConfigurationManager, commandManager, diagnosticsManager, features) {
+    this.features = features;
+    this.providerMap = new Map;
+    this.nextProviderId = 1;
+    this.resolveCodeActionsMap = new Map;
+    this.nextGlobalCodeActionId = 1;
+    this.addProvider(new TypeScriptAutoFixProvider(client, fileConfigurationManager, diagnosticsManager));
+    this.addProvider(new TypeScriptQuickFixProvider(client, fileConfigurationManager, commandManager, diagnosticsManager, features));
+  }
+  get kinds() {
+    const allKinds = [];
+    for (const [_, provider] of this.providerMap) {
+      allKinds.push(...provider.getMetadata().providedCodeActionKinds || []);
+    }
+    return allKinds;
+  }
+  async provideCodeActions(document, range, context, token) {
+    this.resolveCodeActionsMap.clear();
+    const allCodeActions = [];
+    for (const [providerId, provider] of this.providerMap.entries()) {
+      const codeActions = await provider.provideCodeActions(document, range, context, token || nulToken);
+      if (!codeActions) {
+        continue;
+      }
+      for (const action of codeActions) {
+        if (mainExports$2.Command.is(action)) {
+          allCodeActions.push(action);
+          continue;
+        }
+        const lspCodeAction = action.toLspCodeAction();
+        if (provider.isCodeActionResolvable(action)) {
+          const globalId = this.nextGlobalCodeActionId++;
+          this.resolveCodeActionsMap.set(globalId, action);
+          lspCodeAction.data = {
+            globalId: globalId,
+            providerId: providerId
+          };
+        }
+        allCodeActions.push(lspCodeAction);
+      }
+    }
+    return allCodeActions;
+  }
+  async resolveCodeAction(codeAction, token) {
+    if (!this.features.codeActionResolveSupport) {
+      return codeAction;
+    }
+    const {globalId: globalId, providerId: providerId} = codeAction.data || {};
+    if (globalId === undefined || providerId === undefined) {
+      return codeAction;
+    }
+    const provider = this.providerMap.get(providerId);
+    if (!provider || !provider.resolveCodeAction) {
+      return codeAction;
+    }
+    const tsCodeAction = this.resolveCodeActionsMap.get(globalId);
+    if (!tsCodeAction || !providerId) {
+      return codeAction;
+    }
+    const resolvedTsCodeAction = await provider.resolveCodeAction(tsCodeAction, token || nulToken);
+    if (!resolvedTsCodeAction) {
+      return codeAction;
+    }
+    const lspCodeAction = resolvedTsCodeAction.toLspCodeAction();
+    for (const property of this.features.codeActionResolveSupport.properties) {
+      if (property in lspCodeAction) {
+        codeAction[property] = lspCodeAction[property];
+      }
+    }
+    return codeAction;
+  }
+  addProvider(provider) {
+    this.providerMap.set(this.nextProviderId++, provider);
+  }
+}
+
+class LspServer {
+  constructor(options) {
+    this.options = options;
+    this.initializeParams = null;
+    this.completionDataCache = new CompletionDataCache;
+    this.features = {};
+    this.cachedNavTreeResponse = new CachedResponse;
+    this.implementationsCodeLensProvider = null;
+    this.referencesCodeLensProvider = null;
+    this.logger = new PrefixingLogger(options.logger, '[lspserver]');
+    this.tsClient = new TsClient(onCaseInsensitiveFileSystem(), this.logger, options.lspClient);
+    this.fileConfigurationManager = new FileConfigurationManager(this.tsClient, onCaseInsensitiveFileSystem());
+    this.commandManager = new CommandManager;
+    this.diagnosticsManager = new DiagnosticsManager(diagnostics => this.options.lspClient.publishDiagnostics(diagnostics), this.tsClient, this.features, this.logger);
+    this.codeActionsManager = new CodeActionManager(this.tsClient, this.fileConfigurationManager, this.commandManager, this.diagnosticsManager, this.features);
+  }
+  closeAllForTesting() {
+    for (const document of this.tsClient.documentsForTesting.values()) {
+      this.closeDocument(document.uri.toString());
+    }
+  }
+  async waitForDiagnosticsForFile(uri) {
+    const document = this.tsClient.toOpenDocument(uri);
+    if (!document) {
+      throw new Error(`Document not open: ${uri}`);
+    }
+    await this.diagnosticsManager.waitForDiagnosticsForTesting(document.filepath);
+  }
+  shutdown() {
+    this.tsClient.shutdown();
+  }
+  initialize(params) {
+    this.initializeParams = params;
+    const clientCapabilities = this.initializeParams.capabilities;
+    this.workspaceRoot = this.initializeParams.rootUri ? URI.parse(this.initializeParams.rootUri).fsPath : this.initializeParams.rootPath || undefined;
+    const userInitializationOptions = this.initializeParams.initializationOptions || {};
+    const {disableAutomaticTypingAcquisition: disableAutomaticTypingAcquisition, hostInfo: hostInfo, maxTsServerMemory: maxTsServerMemory, npmLocation: npmLocation, locale: locale, plugins: plugins, tsserver: tsserver} = userInitializationOptions;
+    const typescriptVersion = this.findTypescriptVersion(tsserver?.path, tsserver?.fallbackPath);
+    if (typescriptVersion) {
+      this.options.lspClient.logMessage({
+        type: mainExports$2.MessageType.Info,
+        message: `Using Typescript version (${typescriptVersion.source}) ${typescriptVersion.versionString} from path "${typescriptVersion.tsServerPath}"`
+      });
+    } else {
+      throw Error('Could not find a valid TypeScript installation. Please ensure that the "typescript" dependency is installed in the workspace or that a valid `tsserver.path` is specified. Exiting.');
+    }
+    this.fileConfigurationManager.mergeTsPreferences(userInitializationOptions.preferences || {});
+    this.features.completionDisableFilterText = userInitializationOptions.completionDisableFilterText ?? false;
+    this.features.moveToFileCodeActionSupport = userInitializationOptions.supportsMoveToFileCodeAction && typescriptVersion.version?.gte(API.v520);
+    const {textDocument: textDocument} = clientCapabilities;
+    if (textDocument) {
+      const {codeAction: codeAction, completion: completion, definition: definition, publishDiagnostics: publishDiagnostics} = textDocument;
+      if (codeAction) {
+        this.features.codeActionDisabledSupport = codeAction.disabledSupport;
+        this.features.codeActionResolveSupport = codeAction.resolveSupport;
+      }
       if (completion) {
         const {completionItem: completionItem} = completion;
         if (completionItem) {
@@ -22568,10 +23160,10 @@ class LspServer {
     process.on('SIGINT', () => {
       process.exit();
     });
-    this.typeScriptAutoFixProvider = new TypeScriptAutoFixProvider(this.tsClient);
     this.fileConfigurationManager.setGlobalConfiguration(this.workspaceRoot, hostInfo);
     this.registerHandlers();
     const prepareSupport = textDocument?.rename?.prepareSupport && this.tsClient.apiVersion.gte(API.v310);
+    const {codeActionLiteralSupport: codeActionLiteralSupport, resolveSupport: codeActionResolveSupport} = textDocument?.codeAction || {};
     const initializeResult = {
       capabilities: {
         textDocumentSync: mainExports$2.TextDocumentSyncKind.Incremental,
@@ -22579,8 +23171,13 @@ class LspServer {
           triggerCharacters: [ '.', '"', '\'', '/', '@', '<' ],
           resolveProvider: true
         },
-        codeActionProvider: clientCapabilities.textDocument?.codeAction?.codeActionLiteralSupport ? {
-          codeActionKinds: [ ...TypeScriptAutoFixProvider.kinds.map(kind => kind.value), CodeActionKind.SourceOrganizeImportsTs.value, CodeActionKind.SourceRemoveUnusedImportsTs.value, CodeActionKind.SourceSortImportsTs.value, CodeActionKind.QuickFix.value, CodeActionKind.Refactor.value ]
+        codeActionProvider: codeActionLiteralSupport || codeActionResolveSupport ? {
+          ...codeActionLiteralSupport ? {
+            codeActionKinds: [ ...this.codeActionsManager.kinds, CodeActionKind.SourceOrganizeImportsTs.value, CodeActionKind.SourceRemoveUnusedImportsTs.value, CodeActionKind.SourceSortImportsTs.value, CodeActionKind.Refactor.value ]
+          } : {},
+          ...codeActionResolveSupport ? {
+            resolveProvider: true
+          } : {}
         } : true,
         codeLensProvider: {
           resolveProvider: true
@@ -22591,7 +23188,7 @@ class LspServer {
         documentHighlightProvider: true,
         documentSymbolProvider: true,
         executeCommandProvider: {
-          commands: [ Commands.APPLY_WORKSPACE_EDIT, Commands.APPLY_CODE_ACTION, Commands.APPLY_REFACTORING, Commands.CONFIGURE_PLUGIN, Commands.ORGANIZE_IMPORTS, Commands.APPLY_RENAME_FILE, Commands.SOURCE_DEFINITION, Commands.TS_SERVER_REQUEST ]
+          commands: [ Commands.APPLY_REFACTORING, Commands.CONFIGURE_PLUGIN, Commands.ORGANIZE_IMPORTS, Commands.APPLY_RENAME_FILE, Commands.SOURCE_DEFINITION, Commands.TS_SERVER_REQUEST ]
         },
         hoverProvider: true,
         inlayHintProvider: true,
@@ -22702,7 +23299,7 @@ class LspServer {
   didChangeConfiguration(params) {
     this.fileConfigurationManager.setWorkspaceConfiguration(params.settings || {});
     const ignoredDiagnosticCodes = this.fileConfigurationManager.workspaceConfiguration.diagnostics?.ignoredCodes || [];
-    this.tsClient.interruptGetErr(() => this.diagnosticQueue.updateIgnoredDiagnosticCodes(ignoredDiagnosticCodes));
+    this.tsClient.interruptGetErr(() => this.diagnosticsManager.updateIgnoredDiagnosticCodes(ignoredDiagnosticCodes));
   }
   didOpenTextDocument(params) {
     if (this.tsClient.toOpenDocument(params.textDocument.uri, {
@@ -22724,7 +23321,7 @@ class LspServer {
     }
     this.cachedNavTreeResponse.onDocumentClose(document);
     this.tsClient.onDidCloseTextDocument(uri);
-    this.diagnosticQueue.onDidCloseFile(document.filepath);
+    this.diagnosticsManager.onDidCloseFile(document.filepath);
     this.fileConfigurationManager.onDidCloseTextDocument(document.uri);
   }
   didChangeTextDocument(params) {
@@ -23048,13 +23645,9 @@ class LspServer {
     if (!document) {
       return [];
     }
-    await this.tsClient.interruptGetErr(() => this.fileConfigurationManager.ensureConfigurationForDocument(document));
+    const actions = await this.codeActionsManager.provideCodeActions(document, params.range, params.context, token);
     const fileRangeArgs = Range.toFileRangeRequestArgs(document.filepath, params.range);
-    const actions = [];
     const kinds = params.context.only?.map(kind => new CodeActionKind(kind));
-    if (!kinds || kinds.some(kind => CodeActionKind.QuickFix.contains(kind))) {
-      actions.push(...provideQuickFix(await this.getCodeFixes(fileRangeArgs, params.context, token), this.tsClient));
-    }
     if (!kinds || kinds.some(kind => CodeActionKind.Refactor.contains(kind))) {
       actions.push(...provideRefactors(await this.getRefactors(fileRangeArgs, params.context, this.features, token), fileRangeArgs, this.features));
     }
@@ -23084,23 +23677,8 @@ class LspServer {
         }
       }
     }
-    if (kinds && !this.tsClient.hasPendingDiagnostics(document.uri)) {
-      const diagnostics = this.diagnosticQueue.getDiagnosticsForFile(document.filepath) || [];
-      if (diagnostics.length) {
-        actions.push(...await this.typeScriptAutoFixProvider.provideCodeActions(kinds, document.filepath, diagnostics));
-      }
-    }
     return actions;
   }
-  async getCodeFixes(fileRangeArgs, context, token) {
-    const errorCodes = context.diagnostics.map(diagnostic => Number(diagnostic.code));
-    const args = {
-      ...fileRangeArgs,
-      errorCodes: errorCodes
-    };
-    const response = await this.tsClient.execute(CommandTypes.GetCodeFixes, args, token);
-    return response.type === 'response' ? response : undefined;
-  }
   async getRefactors(fileRangeArgs, context, features, token) {
     const kinds = context.only || [ undefined ];
     const responses = await Promise.all(kinds.map(async kind => {
@@ -23115,25 +23693,11 @@ class LspServer {
     }));
     return responses.flat();
   }
+  async codeActionResolve(params, _token) {
+    return this.codeActionsManager.resolveCodeAction(params);
+  }
   async executeCommand(params, token, workDoneProgress) {
-    if (params.command === Commands.APPLY_WORKSPACE_EDIT && params.arguments) {
-      const edit = params.arguments[0];
-      await this.options.lspClient.applyWorkspaceEdit({
-        edit: edit
-      });
-    } else if (params.command === Commands.APPLY_CODE_ACTION && params.arguments) {
-      const codeAction = params.arguments[0];
-      if (!await this.applyFileCodeEdits(codeAction.changes)) {
-        return;
-      }
-      if (codeAction.commands?.length) {
-        for (const command of codeAction.commands) {
-          await this.tsClient.execute(CommandTypes.ApplyCodeActionCommand, {
-            command: command
-          }, token);
-        }
-      }
-    } else if (params.command === Commands.APPLY_REFACTORING && params.arguments) {
+    if (await this.commandManager.handle(params.command, ...params.arguments || [])) ; else if (params.command === Commands.APPLY_REFACTORING && params.arguments) {
       const args = params.arguments[0];
       const response = await this.tsClient.execute(CommandTypes.GetEditsForRefactor, args, token);
       if (response.type !== 'response' || !response.body) {
@@ -23388,7 +23952,7 @@ class LspServer {
       const diagnosticEvent = event;
       if (diagnosticEvent.body?.diagnostics) {
         const {file: file, diagnostics: diagnostics} = diagnosticEvent.body;
-        this.diagnosticQueue.updateDiagnostics(getDignosticsKind(event), file, diagnostics);
+        this.diagnosticsManager.updateDiagnostics(getDignosticsKind(event), file, diagnostics);
       }
     }
   }
@@ -23559,6 +24123,7 @@ function createLspConnection(options) {
   connection.onDidCloseTextDocument(server.didCloseTextDocument.bind(server));
   connection.onDidChangeTextDocument(server.didChangeTextDocument.bind(server));
   connection.onCodeAction(server.codeAction.bind(server));
+  connection.onCodeActionResolve(server.codeActionResolve.bind(server));
   connection.onCodeLens(server.codeLens.bind(server));
   connection.onCodeLensResolve(server.codeLensResolve.bind(server));
   connection.onCompletion(server.completion.bind(server));