@travetto/compiler 3.0.0-rc.14 → 3.0.0-rc.16

package/src/state.ts

@@ -1,35 +1,47 @@
 import ts from 'typescript';
-import { readFileSync } from 'fs';
+import os from 'os';
 
-import { path, ManifestModuleUtil, ManifestModule, ManifestModuleFileType, ManifestRoot, WatchEvent } from '@travetto/manifest';
+import { path, ManifestModuleUtil, ManifestModule, ManifestRoot, ManifestIndex } from '@travetto/manifest';
+import { TransformerManager } from '@travetto/transformer';
 
 import { CompilerUtil } from './util';
 import { TranspileUtil } from '../support/transpile';
+import { CompileStateEntry } from './types';
 
-const validFile = (type: ManifestModuleFileType): boolean => type === 'ts' || type === 'package-json' || type === 'js';
+export class CompilerState implements ts.CompilerHost {
 
-export class CompilerState {
+  static async get(idx: ManifestIndex): Promise<CompilerState> {
+    return new CompilerState().init(idx);
+  }
+
+  private constructor() { }
 
-  #inputFiles: Set<string>;
-  #inputToSource = new Map<string, string>();
-  #stagedOutputToOutput = new Map<string, string>();
-  #inputToOutput = new Map<string, string | undefined>();
+  #rootDir = path.resolve(os.tmpdir(), '_');
+  #outputPath: string;
+  #inputFiles = new Set<string>();
   #inputDirectoryToSource = new Map<string, string>();
-  #sourceInputOutput = new Map<string, { source: string, input: string, stagedOutput?: string, output?: string, module: ManifestModule }>();
+  #inputToEntry = new Map<string, CompileStateEntry>();
+  #sourceToEntry = new Map<string, CompileStateEntry>();
+  #outputToEntry = new Map<string, CompileStateEntry>();
 
   #sourceContents = new Map<string, string | undefined>();
   #sourceFileObjects = new Map<string, ts.SourceFile>();
-  #sourceHashes = new Map<string, number>();
 
+  #manifestIndex: ManifestIndex;
   #manifest: ManifestRoot;
   #modules: ManifestModule[];
-  #transformers: string[];
+  #transformerManager: TransformerManager;
+  #compilerOptions: ts.CompilerOptions;
 
-  constructor(manifest: ManifestRoot) {
-    this.#manifest = manifest;
+  async init(idx: ManifestIndex): Promise<this> {
+    this.#manifestIndex = idx;
+    this.#manifest = idx.manifest;
+    this.#outputPath = path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder);
     this.#modules = Object.values(this.#manifest.modules);
-    this.#inputFiles = new Set(this.#modules.flatMap(
-      x => [
+
+    // Register all inputs
+    for (const x of this.#modules) {
+      const files = [
         ...x.files.bin ?? [],
         ...x.files.src ?? [],
         ...x.files.support ?? [],
@@ -37,67 +49,98 @@ export class CompilerState {
         ...x.files.test ?? [],
         ...x.files.$index ?? [],
         ...x.files.$package ?? []
-      ]
-        .filter(([file, type]) => validFile(type) || type === 'typings')
-        .map(([f]) => this.registerInput(x, f))
-    ));
-
-    this.#transformers = this.#modules.flatMap(
-      x => (x.files.$transformer ?? []).map(([f]) =>
-        path.resolve(manifest.workspacePath, x.sourceFolder, f)
-      )
-    );
-  }
+      ];
+      for (const [file, type] of files) {
+        if (CompilerUtil.validFile(type) || type === 'typings') {
+          this.registerInput(x, file);
+        }
+      }
+    }
+
+    this.#transformerManager = await TransformerManager.create(this.#manifestIndex);
 
-  async getCompilerOptions(): Promise<ts.CompilerOptions> {
-    return {
+    this.#compilerOptions = {
       ...await TranspileUtil.getCompilerOptions(this.#manifest),
-      outDir: this.#manifest.workspacePath, // Force to root
+      rootDir: this.#rootDir,
+      outDir: this.#outputPath
     };
+
+    return this;
+  }
+
+  get manifest(): ManifestRoot {
+    return this.#manifest;
+  }
+
+  get manifestIndex(): ManifestIndex {
+    return this.#manifestIndex;
+  }
+
+  resolveOutputFile(file: string): string {
+    return path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder, file);
+  }
+
+  getArbitraryInputFile(): string {
+    return this.getBySource(this.#manifestIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile)!.input;
+  }
+
+  createProgram(oldProgram?: ts.Program): ts.Program {
+    const prog = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram });
+    this.#transformerManager.init(prog.getTypeChecker());
+    return prog;
+  }
+
+  writeInputFile(program: ts.Program, inputFile: string): ts.EmitResult | undefined {
+    if (inputFile.endsWith('.json')) {
+      this.writeFile(this.#inputToEntry.get(inputFile)!.output!, this.readFile(inputFile)!, false);
+    } else if (inputFile.endsWith('.js')) {
+      this.writeFile(this.#inputToEntry.get(inputFile)!.output!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
+    } else if (inputFile.endsWith('.ts')) {
+      return program.emit(
+        program.getSourceFile(inputFile)!,
+        (...args) => this.writeFile(...args), undefined, false,
+        this.#transformerManager.get()
+      );
+    }
   }
 
-  resolveInput(file: string): string {
-    return this.#sourceInputOutput.get(file)!.input;
+  getBySource(sourceFile: string): CompileStateEntry | undefined {
+    return this.#sourceToEntry.get(sourceFile);
   }
 
   registerInput(module: ManifestModule, moduleFile: string): string {
     const relativeInput = `${module.outputFolder}/${moduleFile}`;
     const sourceFile = path.toPosix(path.resolve(this.#manifest.workspacePath, module.sourceFolder, moduleFile));
     const sourceFolder = path.dirname(sourceFile);
-    const inputFile = path.resolve(this.#manifest.workspacePath, '##', relativeInput); // Ensure input is isolated
+    const inputFile = path.resolve(this.#rootDir, relativeInput); // Ensure input is isolated
     const inputFolder = path.dirname(inputFile);
     const fileType = ManifestModuleUtil.getFileType(moduleFile);
     const outputFile = fileType === 'typings' ?
       undefined :
-      path.resolve(
-        this.#manifest.workspacePath,
-        this.#manifest.outputFolder,
-        CompilerUtil.inputToOutput(relativeInput)
-      );
+      path.resolve(this.#outputPath, CompilerUtil.inputToOutput(relativeInput));
 
-    // Rewrite stagedOutput to final output form
-    const stagedOutputFile = CompilerUtil.inputToOutput(inputFile);
+    const entry = { source: sourceFile, input: inputFile, output: outputFile, module, relativeInput };
 
-    this.#inputToSource.set(inputFile, sourceFile);
-    this.#sourceInputOutput.set(sourceFile, { source: sourceFile, input: inputFile, stagedOutput: stagedOutputFile, output: outputFile, module });
-    this.#inputToOutput.set(inputFile, outputFile);
+    this.#inputToEntry.set(inputFile, entry);
+    this.#sourceToEntry.set(sourceFile, entry);
     this.#inputDirectoryToSource.set(inputFolder, sourceFolder);
 
-    if (stagedOutputFile) {
-      this.#stagedOutputToOutput.set(stagedOutputFile, outputFile!);
-      this.#stagedOutputToOutput.set(`${stagedOutputFile}.map`, `${outputFile!}.map`);
+    if (outputFile) {
+      this.#outputToEntry.set(outputFile, entry);
     }
 
+    this.#inputFiles.add(inputFile);
+
     return inputFile;
   }
 
   removeInput(inputFile: string): void {
-    const source = this.#inputToSource.get(inputFile)!;
-    const { stagedOutput } = this.#sourceInputOutput.get(source)!;
-    this.#stagedOutputToOutput.delete(stagedOutput!);
-    this.#sourceInputOutput.delete(source);
-    this.#inputToSource.delete(inputFile);
-    this.#inputToOutput.delete(inputFile);
+    const { output, source } = this.#inputToEntry.get(inputFile)!;
+    if (output) {
+      this.#outputToEntry.delete(output);
+    }
+    this.#sourceToEntry.delete(source);
+    this.#inputToEntry.delete(inputFile);
     this.#inputFiles.delete(inputFile);
   }
 
@@ -106,106 +149,65 @@ export class CompilerState {
     this.#sourceContents.delete(inputFile);
   }
 
-  get modules(): ManifestModule[] {
-    return this.#modules;
+  getAllFiles(): string[] {
+    return [...this.#inputFiles];
   }
 
-  get transformers(): string[] {
-    return this.#transformers;
+  /**
+   * Used for translating non-project files (e.g. dependencies/node_modules) to the faux-root
+   * that is used during compilation.
+   */
+  translateRawInput(input: string): string {
+    return input.replace(this.#rootDir, this.#manifest.workspacePath);
   }
 
-  getAllFiles(): string[] {
-    return [...this.#inputFiles];
+  /* Start Compiler Host */
+  getCanonicalFileName(file: string): string { return file; }
+  getCurrentDirectory(): string { return path.cwd(); }
+  getDefaultLibFileName(opts: ts.CompilerOptions): string { return ts.getDefaultLibFileName(opts); }
+  getNewLine(): string { return ts.sys.newLine; }
+  useCaseSensitiveFileNames(): boolean { return ts.sys.useCaseSensitiveFileNames; }
+  getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
+
+  fileExists(inputFile: string): boolean {
+    return this.#inputToEntry.has(inputFile) || ts.sys.fileExists(this.translateRawInput(inputFile));
   }
 
-  // Build watcher
-  getWatcher(handler: {
-    create: (inputFile: string) => void;
-    update: (inputFile: string) => void;
-    delete: (outputFile: string) => void;
-  }): (ev: WatchEvent, folder: string) => void {
-    const mods = Object.fromEntries(this.modules.map(x => [path.resolve(this.#manifest.workspacePath, x.sourceFolder), x]));
-    return ({ file: sourceFile, action }: WatchEvent, folder: string): void => {
-      const mod = mods[folder];
-      const moduleFile = sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile;
-      switch (action) {
-        case 'create': {
-          const fileType = ManifestModuleUtil.getFileType(moduleFile);
-          if (validFile(fileType)) {
-            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            const input = this.registerInput(mod, moduleFile);
-            this.#sourceHashes.set(sourceFile, hash);
-            handler.create(input);
-          }
-          break;
-        }
-        case 'update': {
-          const io = this.#sourceInputOutput.get(sourceFile);
-          if (io) {
-            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            if (this.#sourceHashes.get(sourceFile) !== hash) {
-              this.resetInputSource(io.input);
-              this.#sourceHashes.set(sourceFile, hash);
-              handler.update(io.input);
-            }
-          }
-          break;
-        }
-        case 'delete': {
-          const io = this.#sourceInputOutput.get(sourceFile);
-          if (io) {
-            this.removeInput(io.input);
-            if (io.output) {
-              handler.delete(io.output);
-            }
-          }
-        }
-      }
-    };
+  directoryExists(inputDir: string): boolean {
+    return this.#inputDirectoryToSource.has(inputDir) || ts.sys.directoryExists(this.translateRawInput(inputDir));
   }
 
-  // ts.CompilerHost
-  getCompilerHost(options: ts.CompilerOptions): ts.CompilerHost {
-    const host: ts.CompilerHost = {
-      getCanonicalFileName: (file: string): string => file,
-      getCurrentDirectory: path.cwd,
-      getDefaultLibFileName: (opts: ts.CompilerOptions): string => ts.getDefaultLibFileName(opts),
-      getNewLine: (): string => ts.sys.newLine,
-      useCaseSensitiveFileNames: (): boolean => ts.sys.useCaseSensitiveFileNames,
-      getDefaultLibLocation: (): string => path.dirname(ts.getDefaultLibFilePath(options)),
-      fileExists: (inputFile: string): boolean => this.#inputToSource.has(inputFile) || ts.sys.fileExists(inputFile),
-      directoryExists: (inputFolder: string): boolean => this.#inputDirectoryToSource.has(inputFolder) || ts.sys.directoryExists(inputFolder),
-      readFile: (inputFile: string): string | undefined => {
-        const res = this.#sourceContents.get(inputFile) ?? ts.sys.readFile(this.#inputToSource.get(inputFile) ?? inputFile);
-        this.#sourceContents.set(inputFile, res);
-        return res;
-      },
-      writeFile: (
-        outputFile: string,
-        text: string,
-        bom: boolean,
-        onError?: (message: string) => void,
-        sourceFiles?: readonly ts.SourceFile[],
-        data?: ts.WriteFileCallbackData
-      ): void => {
-        if (outputFile.endsWith('package.json')) {
-          text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
-        } else if (!options.inlineSourceMap && options.sourceMap && outputFile.endsWith('.map')) {
-          text = CompilerUtil.rewriteSourceMap(this.#manifest.workspacePath, text, f => this.#sourceInputOutput.get(this.#inputToSource.get(f)!));
-        } else if (options.inlineSourceMap && CompilerUtil.isSourceMapUrlPosData(data)) {
-          text = CompilerUtil.rewriteInlineSourceMap(this.#manifest.workspacePath, text, f => this.#sourceInputOutput.get(this.#inputToSource.get(f)!), data);
-        }
-        outputFile = this.#stagedOutputToOutput.get(outputFile) ?? outputFile;
-        ts.sys.writeFile(outputFile, text, bom);
-      },
-      getSourceFile: (inputFile: string, language: ts.ScriptTarget, __onErr?: unknown): ts.SourceFile => {
-        if (!this.#sourceFileObjects.has(inputFile)) {
-          const content = host.readFile(inputFile)!;
-          this.#sourceFileObjects.set(inputFile, ts.createSourceFile(inputFile, content ?? '', language));
-        }
-        return this.#sourceFileObjects.get(inputFile)!;
-      }
-    };
-    return host;
+  writeFile(
+    outputFile: string,
+    text: string,
+    bom: boolean,
+    onError?: (message: string) => void,
+    sourceFiles?: readonly ts.SourceFile[],
+    data?: ts.WriteFileCallbackData
+  ): void {
+    if (outputFile.endsWith('package.json')) {
+      text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
+    } else if (!this.#compilerOptions.inlineSourceMap && this.#compilerOptions.sourceMap && outputFile.endsWith('.map')) {
+      text = CompilerUtil.rewriteSourceMap(this.#manifest, text, f => this.#outputToEntry.get(f.replace(/[.]map$/, ''))!);
+    } else if (this.#compilerOptions.inlineSourceMap && CompilerUtil.isSourceMapUrlPosData(data)) {
+      text = CompilerUtil.rewriteInlineSourceMap(this.#manifest, text, f => this.#outputToEntry.get(f)!, data);
+    }
+    ts.sys.writeFile(outputFile, text, bom);
+  }
+
+  readFile(inputFile: string): string | undefined {
+    const res = this.#sourceContents.get(inputFile) ?? ts.sys.readFile(
+      this.#inputToEntry.get(inputFile)?.source ?? this.translateRawInput(inputFile)
+    );
+    this.#sourceContents.set(inputFile, res);
+    return res;
+  }
+
+  getSourceFile(inputFile: string, language: ts.ScriptTarget): ts.SourceFile {
+    if (!this.#sourceFileObjects.has(inputFile)) {
+      const content = this.readFile(inputFile)!;
+      this.#sourceFileObjects.set(inputFile, ts.createSourceFile(inputFile, content ?? '', language));
+    }
+    return this.#sourceFileObjects.get(inputFile)!;
   }
 }

package/src/types.ts

@@ -0,0 +1,14 @@
+import type ts from 'typescript';
+
+import type { ManifestModule } from '@travetto/manifest';
+
+export type CompileEmitError = Error | readonly ts.Diagnostic[];
+export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
+export type CompileEmitEvent = { file: string, i: number, total: number, err?: CompileEmitError };
+export type CompileStateEntry = { source: string, input: string, relativeInput: string, output?: string, module: ManifestModule };
+
+export type CompileWatcherHandler = {
+  create: (inputFile: string) => void;
+  update: (inputFile: string) => void;
+  delete: (outputFile: string) => void;
+};

package/src/util.ts

@@ -1,8 +1,8 @@
 import ts from 'typescript';
 
-import { ManifestRoot, Package, path } from '@travetto/manifest';
+import { ManifestContext, ManifestModuleFileType, ManifestRoot, Package, path } from '@travetto/manifest';
 
-type InputToSource = (inputFile: string) => ({ source: string } | undefined);
+type OutputToSource = (outputFile: string) => ({ source: string } | undefined);
 export type FileWatchEvent = { type: 'create' | 'delete' | 'update', path: string };
 
 const nativeCwd = process.cwd();
@@ -12,6 +12,11 @@ const nativeCwd = process.cwd();
  */
 export class CompilerUtil {
 
+  /**
+   * Determine if this is a manifest file we care about
+   */
+  static validFile = (type: ManifestModuleFileType): boolean => type === 'ts' || type === 'package-json' || type === 'js';
+
   /**
    * Map input file to output format, generally converting ts extensions to js
    * @param file
@@ -34,36 +39,35 @@ export class CompilerUtil {
    * Rewrite's sourcemap locations to real folders
    * @returns
    */
-  static rewriteSourceMap(root: string, text: string, inputToSource: InputToSource): string {
-    const data: { sourceRoot: string, sources: string[] } = JSON.parse(text);
-    const src = path.resolve(data.sourceRoot, data.sources[0]);
+  static rewriteSourceMap(ctx: ManifestContext, text: string, outputToSource: OutputToSource): string {
+    const data: { sourceRoot?: string, sources: string[] } = JSON.parse(text);
+    const output = this.inputToOutput(path.resolve(ctx.workspacePath, ctx.outputFolder, data.sources[0]));
+    const { source: file } = outputToSource(output) ?? {};
 
-    const { source: file } = inputToSource(src) ?? {};
     if (file) {
-      data.sourceRoot = root;
+      delete data.sourceRoot;
       data.sources = [file];
       text = JSON.stringify(data);
     }
-
     return text;
   }
 
   /**
    * Rewrite's inline sourcemap locations to real folders
    * @param text
-   * @param inputToSource
+   * @param outputToSource
    * @param writeData
    * @returns
    */
   static rewriteInlineSourceMap(
-    root: string,
+    ctx: ManifestContext,
     text: string,
-    inputToSource: InputToSource,
+    outputToSource: OutputToSource,
     { sourceMapUrlPos }: ts.WriteFileCallbackData & { sourceMapUrlPos: number }
   ): string {
     const sourceMapUrl = text.substring(sourceMapUrlPos);
     const [prefix, sourceMapData] = sourceMapUrl.split('base64,');
-    const rewritten = this.rewriteSourceMap(root, Buffer.from(sourceMapData, 'base64url').toString('utf8'), inputToSource);
+    const rewritten = this.rewriteSourceMap(ctx, Buffer.from(sourceMapData, 'base64url').toString('utf8'), outputToSource);
     return [
       text.substring(0, sourceMapUrlPos),
       prefix,

package/src/watch.ts

@@ -0,0 +1,142 @@
+import { readFileSync } from 'fs';
+import fs from 'fs/promises';
+
+import {
+  ManifestContext, ManifestModuleUtil, ManifestUtil, WatchEvent, ManifestModuleFolderType,
+  ManifestModuleFileType, path, ManifestModule, watchFolders, WatchEventListener
+} from '@travetto/manifest';
+import { getManifestContext } from '@travetto/manifest/bin/context';
+
+import { CompilerState } from './state';
+import { CompilerUtil } from './util';
+import { CompileEmitter, CompileWatcherHandler } from './types';
+
+/**
+ * Utils for watching
+ */
+export class CompilerWatcher {
+
+  #sourceHashes = new Map<string, number>();
+  #manifestContexts = new Map<string, ManifestContext>();
+  #dirtyFiles: { modFolder: string, mod: string, moduleFile?: string, folderKey?: ManifestModuleFolderType, type?: ManifestModuleFileType }[] = [];
+  #state: CompilerState;
+
+  constructor(state: CompilerState) {
+    this.#state = state;
+  }
+
+  async #rebuildManifestsIfNeeded(): Promise<void> {
+    if (!this.#dirtyFiles.length) {
+      return;
+    }
+    const mods = [...new Set(this.#dirtyFiles.map(x => x.modFolder))];
+    const contexts = await Promise.all(mods.map(async folder => {
+      if (!this.#manifestContexts.has(folder)) {
+        const ctx = await getManifestContext(folder);
+        this.#manifestContexts.set(folder, ctx);
+      }
+      return this.#manifestContexts.get(folder)!;
+    }));
+
+    const files = this.#dirtyFiles;
+    this.#dirtyFiles = [];
+
+    for (const ctx of [...contexts, this.#state.manifest]) {
+      const newManifest = await ManifestUtil.buildManifest(ctx);
+      for (const file of files) {
+        if (
+          file.folderKey && file.moduleFile && file.type &&
+          file.mod in newManifest.modules && file.folderKey in newManifest.modules[file.mod].files
+        ) {
+          newManifest.modules[file.mod].files[file.folderKey]!.push([file.moduleFile, file.type, Date.now()]);
+        }
+      }
+      await ManifestUtil.writeManifest(ctx, newManifest);
+    }
+    // Reindex
+    this.#state.manifestIndex.init(this.#state.manifestIndex.manifestFile);
+  }
+
+  #getModuleMap(): Record<string, ManifestModule> {
+    return Object.fromEntries(
+      Object.values(this.#state.manifest.modules).map(x => [path.resolve(this.#state.manifest.workspacePath, x.sourceFolder), x])
+    );
+  }
+
+  /**
+   * Get a watcher for a given compiler state
+   * @param state
+   * @param handler
+   * @returns
+   */
+  #getWatcher(handler: CompileWatcherHandler): WatchEventListener {
+    const mods = this.#getModuleMap();
+
+    return async ({ file: sourceFile, action }: WatchEvent, folder: string): Promise<void> => {
+      const mod = mods[folder];
+      const moduleFile = sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile;
+      switch (action) {
+        case 'create': {
+          const fileType = ManifestModuleUtil.getFileType(moduleFile);
+          this.#dirtyFiles.push({
+            mod: mod.name,
+            modFolder: folder,
+            moduleFile,
+            folderKey: ManifestModuleUtil.getFolderKey(sourceFile),
+            type: ManifestModuleUtil.getFileType(sourceFile)
+          });
+          if (CompilerUtil.validFile(fileType)) {
+            await this.#rebuildManifestsIfNeeded();
+
+            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
+            const input = this.#state.registerInput(mod, moduleFile);
+            this.#sourceHashes.set(sourceFile, hash);
+            handler.create(input);
+          }
+          break;
+        }
+        case 'update': {
+          await this.#rebuildManifestsIfNeeded();
+          const entry = this.#state.getBySource(sourceFile);
+          if (entry) {
+            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
+            if (this.#sourceHashes.get(sourceFile) !== hash) {
+              this.#state.resetInputSource(entry.input);
+              this.#sourceHashes.set(sourceFile, hash);
+              handler.update(entry.input);
+            }
+          }
+          break;
+        }
+        case 'delete': {
+          const entry = this.#state.getBySource(sourceFile);
+          if (entry) {
+            this.#state.removeInput(entry.input);
+            if (entry.output) {
+              this.#dirtyFiles.push({ mod: mod.name, modFolder: folder });
+              handler.delete(entry.output);
+            }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Watch files based on root index
+   */
+  watchFiles(emit: CompileEmitter): Promise<() => Promise<void>> {
+    return watchFolders(
+      this.#state.manifestIndex.getLocalInputFolderMapping(),
+      this.#getWatcher({
+        create: emit,
+        update: emit,
+        delete: (outputFile) => fs.rm(outputFile, { force: true })
+      }),
+      {
+        filter: ev => ev.file.endsWith('.ts') || ev.file.endsWith('.js') || ev.file.endsWith('package.json'),
+        ignore: ['node_modules']
+      }
+    );
+  }
+}