Function performWatchCompilation

packages/compiler-cli/src/perform_watch.ts:132–336

(host: PerformWatchHost)

 * The logic in this function is adapted from `tsc.ts` from TypeScript.
 */
export function performWatchCompilation(host: PerformWatchHost): {
  close: () => void;
  ready: (cb: () => void) => void;
  firstCompileResult: ReadonlyArray<ts.Diagnostic>;
} {
  let cachedProgram: api.Program | undefined; // Program cached from last compilation
  let cachedCompilerHost: api.CompilerHost | undefined; // CompilerHost cached from last compilation
  let cachedOptions: ParsedConfiguration | undefined; // CompilerOptions cached from last compilation
  let timerHandleForRecompilation: QueuedCompilationInfo | undefined; // Handle for 0.25s wait timer to trigger recompilation

  const ignoreFilesForWatch = new Set<string>();
  const fileCache = new Map<string, CacheEntry>();

  const firstCompileResult = doCompilation();

  // Watch basePath, ignoring .dotfiles
  let resolveReadyPromise: () => void;
  const readyPromise = new Promise<void>((resolve) => (resolveReadyPromise = resolve));
  // Note: ! is ok as options are filled after the first compilation
  // Note: ! is ok as resolvedReadyPromise is filled by the previous call
  const fileWatcher = host.onFileChange(
    cachedOptions!.options,
    watchedFileChanged,
    resolveReadyPromise!,
  );

  return {close, ready: (cb) => readyPromise.then(cb), firstCompileResult};

  function cacheEntry(fileName: string): CacheEntry {
    fileName = path.normalize(fileName);
    let entry = fileCache.get(fileName);
    if (!entry) {
      entry = {};
      fileCache.set(fileName, entry);
    }
    return entry;
  }

  function close() {
    fileWatcher.close();
    if (timerHandleForRecompilation) {
      host.clearTimeout(timerHandleForRecompilation.timerHandle);
      timerHandleForRecompilation = undefined;
    }
  }

  // Invoked to perform initial compilation or re-compilation in watch mode
  function doCompilation(): ReadonlyArray<ts.Diagnostic> {
    if (!cachedOptions) {
      cachedOptions = host.readConfiguration();
    }
    if (cachedOptions.errors && cachedOptions.errors.length) {
      host.reportDiagnostics(cachedOptions.errors);
      return cachedOptions.errors;
    }
    const startTime = Date.now();
    if (!cachedCompilerHost) {
      cachedCompilerHost = host.createCompilerHost(cachedOptions.options);