LanguageService API

service.cleanupSemanticCache();

service.dispose();

const errors = service.getSyntacticDiagnostics('app.ts');
errors.forEach(error => {
  const { line, character } = error.file!.getLineAndCharacterOfPosition(
    error.start!
  );
  console.log(`${error.file!.fileName}:${line}:${character}`);
  console.log(`  ${error.messageText}`);
});

const errors = service.getSemanticDiagnostics('app.ts');
errors.forEach(error => {
  if (error.file) {
    const { line, character } = error.file.getLineAndCharacterOfPosition(
      error.start!
    );
    console.log(`${error.file.fileName}:${line}:${character}`);
  }
  console.log(`  ${error.messageText}`);
});

const suggestions = service.getSuggestionDiagnostics('app.ts');
// Example: "This may be converted to an async function"

const configErrors = service.getCompilerOptionsDiagnostics();
// Example: "Option 'target' must be one of: ..."

const completions = service.getCompletionsAtPosition(
  'app.ts',
  position,
  {
    includeCompletionsForModuleExports: true,
    includeCompletionsWithInsertText: true,
    includeAutomaticOptionalChainCompletions: true
  }
);

if (completions) {
  completions.entries.forEach(entry => {
    console.log(`${entry.name} (${entry.kind})`);
  });
}

const details = service.getCompletionEntryDetails(
  'app.ts',
  position,
  'functionName',
  formatOptions,
  undefined, // source
  preferences,
  undefined  // data
);

if (details) {
  console.log(details.displayParts.map(p => p.text).join(''));
  console.log(details.documentation?.map(d => d.text).join(''));
}

const symbol = service.getCompletionEntrySymbol(
  'app.ts',
  position,
  'myFunction',
  undefined
);

const quickInfo = service.getQuickInfoAtPosition('app.ts', position);

if (quickInfo) {
  const description = quickInfo.displayParts
    ?.map(p => p.text)
    .join('');
  const docs = quickInfo.documentation
    ?.map(d => d.text)
    .join('');
    
  console.log(description);
  console.log(docs);
}

const signatureHelp = service.getSignatureHelpItems(
  'app.ts',
  position,
  { triggerReason: { kind: 'invoked' } }
);

if (signatureHelp) {
  const item = signatureHelp.items[signatureHelp.selectedItemIndex];
  console.log(item.prefixDisplayParts.map(p => p.text).join(''));
}

const definitions = service.getDefinitionAtPosition('app.ts', position);

definitions?.forEach(def => {
  console.log(`${def.fileName}:${def.textSpan.start}`);
});

const result = service.getDefinitionAndBoundSpan('app.ts', position);

if (result) {
  console.log('Identifier span:', result.textSpan);
  result.definitions?.forEach(def => {
    console.log(`Definition: ${def.fileName}:${def.textSpan.start}`);
  });
}

const typeDefs = service.getTypeDefinitionAtPosition('app.ts', position);
// Navigate to the type definition, not the variable declaration

const implementations = service.getImplementationAtPosition(
  'app.ts',
  position
);

implementations?.forEach(impl => {
  console.log(`Implementation: ${impl.fileName}`);
});

const references = service.getReferencesAtPosition('app.ts', position);

references?.forEach(ref => {
  console.log(`${ref.fileName}:${ref.textSpan.start}`);
});

const referenced = service.findReferences('app.ts', position);

referenced?.forEach(group => {
  console.log('Definition:', group.definition.name);
  group.references.forEach(ref => {
    console.log(`  ${ref.fileName}:${ref.textSpan.start}`);
  });
});

const renameInfo = service.getRenameInfo('app.ts', position, preferences);

if (renameInfo.canRename) {
  console.log(`Can rename: ${renameInfo.displayName}`);
} else {
  console.log(`Cannot rename: ${renameInfo.localizedErrorMessage}`);
}

const locations = service.findRenameLocations(
  'app.ts',
  position,
  false, // findInStrings
  false, // findInComments
  preferences
);

locations?.forEach(loc => {
  console.log(`${loc.fileName}:${loc.textSpan.start}`);
});

const refactors = service.getApplicableRefactors(
  'app.ts',
  { pos: start, end },
  preferences,
  { kind: 'invoked' }
);

refactors.forEach(refactor => {
  console.log(`${refactor.name}: ${refactor.description}`);
  refactor.actions.forEach(action => {
    console.log(`  - ${action.name}: ${action.description}`);
  });
});

const edits = service.getEditsForRefactor(
  'app.ts',
  formatOptions,
  { pos: start, end },
  'Extract Function',
  'function_scope_0',
  preferences
);

if (edits) {
  applyFileTextChanges(edits.edits);
}

const changes = service.organizeImports(
  {
    type: 'file',
    fileName: 'app.ts',
    mode: ts.OrganizeImportsMode.All
  },
  formatOptions,
  preferences
);

applyFileTextChanges(changes);

const fixes = service.getCodeFixesAtPosition(
  'app.ts',
  start,
  end,
  [2304], // Error code for "Cannot find name"
  formatOptions,
  preferences
);

fixes.forEach(fix => {
  console.log(fix.description);
});

const supported = service.getSupportedCodeFixes();
console.log(supported); // ['2304', '2307', ...]

const edits = service.getFormattingEditsForRange(
  'app.ts',
  start,
  end,
  {
    indentSize: 2,
    tabSize: 2,
    insertSpaceAfterCommaDelimiter: true
  }
);

applyTextChanges(edits);

const edits = service.getFormattingEditsForDocument(
  'app.ts',
  formatOptions
);

const edits = service.getFormattingEditsAfterKeystroke(
  'app.ts',
  position,
  '}',
  formatOptions
);

const program = service.getProgram();
if (program) {
  const typeChecker = program.getTypeChecker();
  const sourceFiles = program.getSourceFiles();
}