@simplysm/sd-cli 6.0.19 → 6.0.27

package/src/build-tools/SdCliNgLibraryBuilder.ts

@@ -1,225 +0,0 @@
-import * as ts from "typescript";
-import { ISdPackageBuildResult } from "../commons";
-import * as path from "path";
-import { SdTsDiagnosticUtil } from "../utils/SdTsDiagnosticUtil";
-import { NgccProcessingCache } from "ng-packagr/lib/ng-package/ngcc-cache";
-import { NgccProcessor } from "ng-packagr/lib/ngc/ngcc-processor";
-import { EntryPointNode } from "ng-packagr/lib/ng-package/nodes";
-import { ngccTransformCompilerHost } from "ng-packagr/lib/ts/ngcc-transform-compiler-host";
-import { NgtscProgram } from "@angular/compiler-cli";
-import { ITsBuildFileCache, SdCliTypescriptBuilder } from "./SdCliTypescriptBuilder";
-import { NgCompiler } from "@angular/compiler-cli/src/ngtsc/core";
-import { NeverEntryError } from "@simplysm/sd-core-common";
-import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
-import * as os from "os";
-import * as nodeSass from "node-sass";
-import { createHash } from "crypto";
-
-export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
-  protected _ngProgram?: NgtscProgram;
-  protected _ngCompiler?: NgCompiler;
-  private readonly _ngccProcessingCache = new NgccProcessingCache();
-
-  protected override readonly _fileCache = new Map<string, (ITsBuildFileCache & { scssResult?: { content: string; dependencies: string[] } })>();
-
-  public constructor(public rootPath: string,
-                     public tsconfigFilePath: string) {
-    super(rootPath, tsconfigFilePath);
-
-    this._parsedTsconfig = {
-      ...this._parsedTsconfig,
-      options: {
-        baseUrl: path.dirname(this.tsconfigFilePath),
-        enableI18nLegacyMessageIdFormat: false,
-        strictInjectionParameters: true,
-        strictInputAccessModifiers: true,
-        strictTemplates: true,
-        strictInputTypes: false,
-        ...this._parsedTsconfig.options
-      }
-    };
-  }
-
-  protected override async _runProgramAsync(dirtySourceFiles?: ts.SourceFile[]): Promise<ISdPackageBuildResult[]> {
-    if (!this._ngCompiler) throw new NeverEntryError();
-    if (!this._builder) throw new NeverEntryError();
-
-    const diagnostics = [
-      ...this._ngCompiler.getOptionDiagnostics(),
-      ...this._builder.getOptionsDiagnostics(),
-      ...this._builder.getGlobalDiagnostics()
-    ];
-
-    await this._ngCompiler.analyzeAsync();
-
-    const currDirtySourceFiles = dirtySourceFiles ?? this._builder.getSourceFiles();
-
-    for (const sourceFile of currDirtySourceFiles) {
-      diagnostics.push(...[
-        ...this._builder.getSyntacticDiagnostics(sourceFile),
-        ...this._builder.getSemanticDiagnostics(sourceFile)
-      ]);
-    }
-
-    const transformers = this._ngCompiler.prepareEmit().transformers;
-
-    for (const sourceFile of currDirtySourceFiles) {
-      this._builder.emit(sourceFile, undefined, undefined, undefined, transformers);
-    }
-
-    return diagnostics.map((item) => SdTsDiagnosticUtil.convertDiagnosticsToResult(item)).filterExists();
-  }
-
-  protected override _reloadProgram(watch: boolean): ts.SourceFile[] | undefined {
-    const moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, this._parsedTsconfig.options);
-    const cacheCompilerHost = this._createCacheCompilerHost(this._parsedTsconfig, moduleResolutionCache);
-
-    this._ngProgram = new NgtscProgram(
-      this._parsedTsconfig.fileNames,
-      this._parsedTsconfig.options,
-      cacheCompilerHost,
-      this._ngProgram
-    );
-
-    this._ngCompiler = this._ngProgram.compiler;
-    this._program = this._ngProgram.getTsProgram();
-
-    const baseGetSourceFiles = this._program.getSourceFiles;
-    this._program.getSourceFiles = function (...parameters) {
-      const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
-
-      for (const file of files) {
-        if (file.version === undefined) {
-          file.version = createHash("sha256").update(file.text).digest("hex");
-        }
-      }
-
-      return files;
-    };
-
-    if (watch) {
-      const builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-        this._program,
-        cacheCompilerHost,
-        this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
-      );
-      this._builder = builder;
-
-      const results: ts.SourceFile[] = [];
-      while (true) {
-        const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-          return this._ngCompiler!.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts");
-        });
-
-        if (result && "fileName" in result.affected) {
-          results.push(result.affected);
-        }
-        if (!result) break;
-      }
-      return results;
-    }
-    else {
-      this._builder = ts.createAbstractBuilder(this._program, cacheCompilerHost);
-      return undefined;
-    }
-  }
-
-  protected override _createCacheCompilerHost(parsedTsconfig: ts.ParsedCommandLine, moduleResolutionCache: ts.ModuleResolutionCache): ts.CompilerHost {
-    const tsCacheCompilerHost = super._createCacheCompilerHost(parsedTsconfig, moduleResolutionCache);
-
-    const ngccProcessor = new NgccProcessor(
-      this._ngccProcessingCache,
-      this.tsconfigFilePath,
-      parsedTsconfig.options,
-      parsedTsconfig.fileNames.map((item) => ({ url: item }) as EntryPointNode)
-    );
-
-    const ngCompilerHost = ngccTransformCompilerHost(
-      tsCacheCompilerHost,
-      parsedTsconfig.options,
-      ngccProcessor,
-      moduleResolutionCache
-    );
-
-    const resultCompilerHost = { ...ngCompilerHost };
-    resultCompilerHost.writeFile = (fileName: string,
-                                    data: string,
-                                    writeByteOrderMark: boolean,
-                                    onError?: (message: string) => void,
-                                    sourceFiles?: readonly ts.SourceFile[]) => {
-      if (!fileName.includes(".ngtypecheck.")) {
-        ngCompilerHost.writeFile.call(resultCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
-      }
-    };
-
-    resultCompilerHost.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget) => {
-      const cache = this._fileCache.getOrCreate(PathUtil.posix(fileName), {});
-
-      if (cache.scssResult === undefined && fileName.endsWith(".ts") && !fileName.endsWith(".d.ts")) {
-        const orgContent = FsUtil.readFile(fileName);
-        cache.scssResult = this._replaceScssToCss(fileName, orgContent);
-      }
-      if (cache.sourceFile === undefined) {
-        if (cache.scssResult) {
-          cache.sourceFile = ts.createSourceFile(fileName, cache.scssResult.content, languageVersion);
-        }
-        else {
-          cache.sourceFile = ngCompilerHost.getSourceFile.call(resultCompilerHost, fileName, languageVersion);
-        }
-      }
-      if (cache.dependencyFilePaths === undefined) {
-        cache.dependencyFilePaths = [
-          ...this._getDependencyFilePaths(
-            cache.sourceFile!,
-            parsedTsconfig.options,
-            ngCompilerHost,
-            moduleResolutionCache
-          ),
-          ...cache.scssResult ? cache.scssResult.dependencies : []
-        ];
-      }
-      return cache.sourceFile;
-    };
-
-    return resultCompilerHost;
-  }
-
-  private _replaceScssToCss(filePath: string, content: string): { content: string; dependencies: string[] } {
-    const scssRegex = /\/\* *language=SCSS *\*\/ *[`"'](((?!['"`]\)?[\],][,;]?[\r\n\\])(.|\r|\n))*)['"`]/;
-
-    const matches = content.match(new RegExp(scssRegex, "gi"));
-    if (!matches) {
-      return { content, dependencies: [] };
-    }
-
-    const results = matches.map((match) => nodeSass.renderSync({
-      file: filePath,
-      data: scssRegex.exec(match)?.[1],
-      precision: 8,
-      includePaths: [],
-      outputStyle: "expanded",
-      sourceMapEmbed: false,
-      sourceMap: false
-    }));
-
-    const deps = results.mapMany((result) => result.stats.includedFiles).map((item) => path.resolve(item));
-
-    let i = 0;
-    const newContent = content.replace(new RegExp(scssRegex, "gi"), () => {
-      let result = "`" + results[i].css.toString() + "`";
-      const prev = matches[i];
-
-      const diffCount = Array.from(prev).filter((item) => item === "\n").length
-        - Array.from(result).filter((item) => item === "\n").length;
-
-      for (let j = 0; j < diffCount; j++) {
-        result += os.EOL;
-      }
-
-      i += 1;
-      return result;
-    });
-
-    return { content: newContent, dependencies: deps };
-  }
-}

package/src/build-tools/SdCliTypescriptBuilder.ts

@@ -1,424 +0,0 @@
-import * as ts from "typescript";
-import { INpmConfig, ISdPackageBuildResult, ITsconfig } from "../commons";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
-import { NeverEntryError, StringUtil } from "@simplysm/sd-core-common";
-import { EventEmitter } from "events";
-import * as path from "path";
-import { SdTsDiagnosticUtil } from "../utils/SdTsDiagnosticUtil";
-import { ESLint } from "eslint";
-import { createHash } from "crypto";
-
-export class SdCliTypescriptBuilder extends EventEmitter {
-  private readonly _logger: Logger;
-
-  protected _parsedTsconfig: ts.ParsedCommandLine;
-  public readonly npmConfig: INpmConfig;
-
-  protected _program?: ts.Program;
-  protected _builder?: ts.BuilderProgram | ts.EmitAndSemanticDiagnosticsBuilderProgram;
-  protected readonly _fileCache: Map<string, ITsBuildFileCache> = new Map<string, ITsBuildFileCache>();
-
-  private readonly _resultMap = new Map<string, ISdPackageBuildResult[]>();
-
-  public constructor(public rootPath: string,
-                     public tsconfigFilePath: string,
-                     public noEmit: boolean = false) {
-    super();
-
-    const tsconfig: ITsconfig = FsUtil.readJson(this.tsconfigFilePath);
-    this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this.rootPath);
-
-    this.npmConfig = FsUtil.readJson(path.resolve(this.rootPath, "package.json"));
-    this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this.npmConfig.name]);
-  }
-
-  public on(event: "change", listener: () => void): this;
-  public on(event: "complete", listener: (results: ISdPackageBuildResult[]) => void): this;
-  public on(event: string | symbol, listener: (...args: any[]) => void): this {
-    return super.on(event, listener);
-  }
-
-  public async buildAsync(watch: boolean): Promise<void> {
-    this.emit("change");
-
-    // DIST 비우기
-    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
-    if (this._parsedTsconfig.options.declarationDir !== undefined) {
-      await FsUtil.removeAsync(this._parsedTsconfig.options.declarationDir);
-    }
-
-    this._reloadProgram(watch);
-
-    if (watch) {
-      const watchPaths = this._getWatchPaths();
-      const watcher = new SdFsWatcher();
-      watcher
-        .on("change", async (changeInfos) => {
-          try {
-            const dirtyFilePaths = changeInfos
-              .map((item) => PathUtil.posix(item.filePath))
-              .filter((item) => path.basename(item).includes("."))
-              .distinct();
-            if (dirtyFilePaths.length === 0) return;
-
-            this.emit("change");
-
-            this._deleteFileCaches(dirtyFilePaths);
-
-            const reloadedSourceFiles = this._reloadProgram(watch)!;
-
-            const watchPaths2 = this._getWatchPaths();
-            watcher.replaceWatchPaths(watchPaths2);
-
-            // 빌드 및 린트
-            const results = await this._doAllAsync(reloadedSourceFiles);
-
-            // 결과 MAP에서 DIRTY FILE 삭제
-            this._resultMap.delete("undefined");
-            const allDirtyPosixFilePaths = reloadedSourceFiles
-              .map((item) => item.fileName)
-              .concat(dirtyFilePaths)
-              .map((item) => PathUtil.posix(item))
-              .distinct();
-            for (const allDirtyPosixFilePath of allDirtyPosixFilePaths) {
-              this._resultMap.delete(allDirtyPosixFilePath);
-            }
-
-            // 결과 MAP 구성
-            for (const result of results) {
-              const posixFilePath = result.filePath !== undefined ? PathUtil.posix(result.filePath) : "undefined";
-              const resultMapValue = this._resultMap.getOrCreate(posixFilePath, []);
-              resultMapValue.push(result);
-            }
-
-            this.emit("complete", Array.from(this._resultMap.values()).mapMany());
-          }
-          catch (err) {
-            this.emit("complete", [{
-              filePath: undefined,
-              severity: "error",
-              message: err.stack ?? err.message
-            }]);
-          }
-        })
-        .watch(watchPaths);
-
-      // 빌드 및 린트
-      const results = await this._doAllAsync();
-
-      // 결과 MAP 구성
-      for (const result of results) {
-        const posixFilePath = result.filePath !== undefined ? PathUtil.posix(result.filePath) : "undefined";
-        const resultMapValue = this._resultMap.getOrCreate(posixFilePath, []);
-        resultMapValue.push(result);
-      }
-      this.emit("complete", Array.from(this._resultMap.values()).mapMany());
-    }
-    else {
-      const results = await this._doAllAsync();
-      this.emit("complete", results);
-    }
-  }
-
-  protected async _doAllAsync(dirtySourceFiles?: ts.SourceFile[]): Promise<ISdPackageBuildResult[]> {
-    return (
-      await Promise.all([
-        (async () => {
-          this._logger.debug("빌드 시작");
-          const result = await this._runProgramAsync(dirtySourceFiles);
-          this._logger.debug("빌드 완료");
-          return result;
-        })(),
-        (async () => {
-          this._logger.debug("린트 시작");
-          const result = await this._lintAsync(dirtySourceFiles);
-          this._logger.debug("린트 완료");
-          return result;
-        })()
-      ])
-    ).mapMany();
-  }
-
-  protected async _lintAsync(dirtySourceFiles?: ts.SourceFile[]): Promise<ISdPackageBuildResult[]> {
-    const linter = new ESLint({
-      overrideConfig: {
-        overrides: [
-          {
-            files: ["*.ts"],
-            parserOptions: {
-              program: this._program
-            },
-            settings: {
-              "import/resolver": {
-                typescript: {
-                  project: this.tsconfigFilePath
-                }
-              }
-            }
-          }
-        ]
-      }
-    });
-
-    const currDirtySourceFiles = dirtySourceFiles ?? this._builder!.getSourceFiles();
-    const lintFilePaths = currDirtySourceFiles
-      .map((item) => item.fileName)
-      .filter((item) => (
-        !item.includes("node_modules")
-        && FsUtil.isChildPath(item, this.rootPath)
-        && FsUtil.exists(item)
-        && !FsUtil.isDirectory(item)
-      ))
-      .distinct();
-    const lintResults = await linter.lintFiles(lintFilePaths);
-
-    return lintResults.mapMany((report) => (
-      report.messages.map((msg) => {
-        const severity: "warning" | "error" = msg.severity === 1 ? "warning" : "error";
-
-        return {
-          filePath: report.filePath,
-          severity,
-          message: `${report.filePath}(${msg.line}, ${msg.column}): ${msg.ruleId ?? ""}: ${severity} ${msg.message}`
-        };
-      })
-    ));
-  }
-
-  protected _getWatchPaths(): string[] {
-    return Array.from(this._fileCache.entries())
-      .mapMany((item) => [item[0], ...item[1].dependencyFilePaths ?? []])
-      .map((item) => PathUtil.posix(path.dirname(item)))
-      .distinct();
-  }
-
-  protected _deleteFileCaches(filePaths: string[]): void {
-    for (const filePath of filePaths) {
-      const cachedFileInfo = this._fileCache.get(filePath);
-      if (cachedFileInfo) {
-        if (!StringUtil.isNullOrEmpty(cachedFileInfo.jsFilePath)) {
-          FsUtil.remove(cachedFileInfo.jsFilePath);
-        }
-        if (!StringUtil.isNullOrEmpty(cachedFileInfo.dtsFilePath)) {
-          FsUtil.remove(cachedFileInfo.dtsFilePath);
-        }
-      }
-      this._fileCache.delete(filePath);
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  protected async _runProgramAsync(dirtySourceFiles?: ts.SourceFile[]): Promise<ISdPackageBuildResult[]> {
-    if (!this._builder) throw new NeverEntryError();
-
-    const diagnostics = [
-      ...this._builder.getOptionsDiagnostics(),
-      ...this._builder.getGlobalDiagnostics()
-    ];
-
-    const currDirtySourceFiles = dirtySourceFiles ?? this._builder.getSourceFiles();
-
-    for (const sourceFile of currDirtySourceFiles) {
-      diagnostics.push(...[
-        ...this._builder.getSyntacticDiagnostics(sourceFile),
-        ...this._builder.getSemanticDiagnostics(sourceFile)
-      ]);
-    }
-
-    if (!this.noEmit) {
-      for (const sourceFile of currDirtySourceFiles) {
-        this._builder.emit(sourceFile);
-      }
-    }
-
-    return diagnostics.map((item) => SdTsDiagnosticUtil.convertDiagnosticsToResult(item)).filterExists();
-  }
-
-  protected _reloadProgram(watch: boolean): ts.SourceFile[] | undefined {
-    const moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, this._parsedTsconfig.options);
-    const cacheCompilerHost = this._createCacheCompilerHost(this._parsedTsconfig, moduleResolutionCache);
-
-    this._program = ts.createProgram(
-      this._parsedTsconfig.fileNames,
-      this._parsedTsconfig.options,
-      cacheCompilerHost,
-      this._program
-    );
-
-    const baseGetSourceFiles = this._program.getSourceFiles;
-    this._program.getSourceFiles = function (...parameters) {
-      const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
-
-      for (const file of files) {
-        if (file.version === undefined) {
-          file.version = createHash("sha256").update(file.text).digest("hex");
-        }
-      }
-
-      return files;
-    };
-
-    if (watch) {
-      const builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-        this._program,
-        cacheCompilerHost,
-        this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
-      );
-      this._builder = builder;
-
-      const results: ts.SourceFile[] = [];
-      while (true) {
-        const result = builder.getSemanticDiagnosticsOfNextAffectedFile();
-        if (result && "fileName" in result.affected) {
-          results.push(result.affected);
-        }
-        if (!result) break;
-      }
-      return results;
-    }
-    else {
-      this._builder = ts.createAbstractBuilder(this._program, cacheCompilerHost);
-      return undefined;
-    }
-  }
-
-  protected _createCacheCompilerHost(parsedTsconfig: ts.ParsedCommandLine, moduleResolutionCache: ts.ModuleResolutionCache): ts.CompilerHost {
-    const compilerHost = ts.createCompilerHost(parsedTsconfig.options);
-
-    const cacheCompilerHost = { ...compilerHost };
-    cacheCompilerHost.fileExists = (fileName: string) => {
-      const cache = this._fileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (cache.exists === undefined) {
-        cache.exists = compilerHost.fileExists.call(cacheCompilerHost, fileName);
-      }
-      return cache.exists;
-    };
-
-    cacheCompilerHost.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget) => {
-      const cache = this._fileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (!cache.sourceFile) {
-        cache.sourceFile = compilerHost.getSourceFile.call(cacheCompilerHost, fileName, languageVersion);
-      }
-      if (!cache.dependencyFilePaths) {
-        cache.dependencyFilePaths = this._getDependencyFilePaths(
-          cache.sourceFile!,
-          parsedTsconfig.options,
-          compilerHost,
-          moduleResolutionCache
-        );
-      }
-      return cache.sourceFile;
-    };
-
-    cacheCompilerHost.writeFile = (fileName: string,
-                                   data: string,
-                                   writeByteOrderMark: boolean,
-                                   onError?: (message: string) => void,
-                                   sourceFiles?: readonly ts.SourceFile[]) => {
-      if (sourceFiles && fileName.endsWith(".d.ts")) {
-        sourceFiles.forEach((source) => {
-          const cache = this._fileCache.getOrCreate(PathUtil.posix(source.fileName), {});
-          if (StringUtil.isNullOrEmpty(cache.dtsFilePath)) {
-            cache.dtsFilePath = fileName;
-            compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
-          }
-        });
-      }
-      else if (sourceFiles && fileName.endsWith(".js")) {
-        sourceFiles.forEach((source) => {
-          const cache = this._fileCache.getOrCreate(PathUtil.posix(source.fileName), {});
-          if (StringUtil.isNullOrEmpty(cache.jsFilePath)) {
-            cache.jsFilePath = fileName;
-            compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
-          }
-        });
-      }
-      else {
-        compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
-      }
-    };
-
-    cacheCompilerHost.readFile = (fileName: string) => {
-      const cache = this._fileCache.getOrCreate(PathUtil.posix(fileName), {});
-      if (cache.content === undefined) {
-        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
-      }
-      return cache.content;
-    };
-
-    cacheCompilerHost.resolveModuleNames = (moduleNames: string[], containingFile: string) => {
-      return moduleNames.map((moduleName) => {
-        return ts.resolveModuleName(
-          moduleName,
-          containingFile,
-          parsedTsconfig.options,
-          compilerHost,
-          moduleResolutionCache
-        ).resolvedModule;
-      });
-    };
-
-    return cacheCompilerHost;
-  }
-
-  protected _getDependencyFilePaths(sourceFile: ts.SourceFile,
-                                    compilerOptions: ts.CompilerOptions,
-                                    compilerHost: ts.CompilerHost,
-                                    moduleResolutionCache: ts.ModuleResolutionCache): string[] {
-    const result: string[] = [];
-    ts.forEachChild(sourceFile, (node) => {
-      if (ts.isImportDeclaration(node) || ts.isImportEqualsDeclaration(node) || ts.isExportDeclaration(node)) {
-        const exp = this._getDependencyExpression(node);
-        if (exp && ts.isStringLiteral(exp)) {
-          const moduleName = exp.text;
-
-          const resolvedModule = ts.resolveModuleName(
-            moduleName,
-            sourceFile.fileName,
-            compilerOptions,
-            compilerHost,
-            moduleResolutionCache
-          ).resolvedModule;
-
-          if (resolvedModule) {
-            result.push(PathUtil.posix(resolvedModule.resolvedFileName));
-          }
-          else if (moduleName.startsWith(".")) {
-            result.push(...[
-              PathUtil.posix(path.dirname(sourceFile.fileName), moduleName),
-              PathUtil.posix(path.dirname(sourceFile.fileName), moduleName) + ".ts",
-              PathUtil.posix(path.dirname(sourceFile.fileName), moduleName) + ".d.ts"
-            ]);
-          }
-        }
-      }
-    });
-    return result;
-  }
-
-  protected _getDependencyExpression(node: ts.Node): ts.Expression | undefined {
-    if (ts.isImportDeclaration(node)) {
-      return node.moduleSpecifier;
-    }
-    else if (ts.isImportEqualsDeclaration(node)) {
-      const reference = node.moduleReference;
-      if (ts.isExternalModuleReference(reference)) {
-        return reference.expression;
-      }
-    }
-    else if (ts.isExportDeclaration(node)) {
-      return node.moduleSpecifier;
-    }
-
-    return undefined;
-  }
-}
-
-export interface ITsBuildFileCache {
-  exists?: boolean;
-  sourceFile?: ts.SourceFile;
-  dtsFilePath?: string;
-  jsFilePath?: string;
-  content?: string;
-  dependencyFilePaths?: string[];
-}