@marko/type-check 0.0.18 → 1.0.1

package/README.md

@@ -25,7 +25,6 @@ mtc [options]
 | ---------------- | ----- | ---------------------------------------------------------------------- | ---------------------------------- |
 | --project <path> | -p    | Path to the tsconfig or jsconfig file                                  | ./tsconfig.json or ./jsconfig.json |
 | --display <type> | -d    | Set the display type for error output. Choices: codeframe or condensed | codeframe                          |
-| --emit           | -e    | Emit .js, .d.ts, .marko (with types stripped), and .d.marko files      | false                              |
 | --help           | -h    | Display the help text                                                  |                                    |
 | --version        | -v    | Display the CLI version, Marko version, and TypeScript version         |                                    |
 
@@ -43,17 +42,11 @@ marko-type-check
 mtc -p ./jsconfig.json -d condensed
 ```
 
-### Run type check and emit output files:
-
-```
-marko-type-check -e
-```
-
 ## FAQ
 
-### What files are emitted with the `--emit` option?
+### What files are emitted?
 
-The `emit` option outputs files similar to the [`tsc` cli](https://www.typescriptlang.org/docs/handbook/compiler-options.html). Meaning `.js` and `.d.ts` files will be output. Beyond that `.marko` files _with their types stripped_ and an associated `.d.marko` file will be output that serve a similar purpose to the `.js` and `.d.ts` files.
+Outputs files are similar to the [`tsc` cli in build mode](https://www.typescriptlang.org/docs/handbook/project-references.html). Meaning `.js` and `.d.ts` files will be output (depending on your project config). Beyond that `.marko` files _with their types stripped_ and an associated `.d.marko` file will be output that serve a similar purpose to the `.js` and `.d.ts` files.
 
 ### What is a `.d.marko` file?
 

package/dist/cli.js

@@ -32,6 +32,7 @@ var import_kleur2 = __toESM(require("kleur"));
 
 // src/run.ts
 var import_path = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
 var import_tsserverlibrary = __toESM(require("typescript/lib/tsserverlibrary"));
 var import_kleur = __toESM(require("kleur"));
 var import_code_frame = require("@babel/code-frame");
@@ -41,424 +42,371 @@ var Display = {
   condensed: "condensed"
 };
 var currentDirectory = import_tsserverlibrary.default.sys.getCurrentDirectory();
+var getCanonicalFileName = import_tsserverlibrary.default.sys.useCaseSensitiveFileNames ? (fileName) => fileName : (fileName) => fileName.toLowerCase();
 var fsPathReg = /^(?:[./\\]|[A-Z]:)/i;
 var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
 var extractCache = /* @__PURE__ */ new WeakMap();
 var requiredTSCompilerOptions = {
   allowJs: true,
+  composite: true,
+  incremental: true,
   declaration: true,
   skipLibCheck: true,
   isolatedModules: true,
   allowNonTsExtensions: true
 };
-var requiredTSCompilerOptionsEmit = {
-  ...requiredTSCompilerOptions,
-  noEmit: false,
-  declaration: true,
-  emitDeclarationOnly: false
-};
-var requiredTSCompilerOptionsNoEmit = {
-  ...requiredTSCompilerOptions,
-  noEmit: true,
-  declaration: false,
-  emitDeclarationOnly: false
-};
-var defaultTSConfig = {
-  include: [],
-  compilerOptions: {
-    lib: ["dom", "node", "esnext"]
-  }
-};
 function run(opts) {
-  var _a;
   const {
-    emit = false,
     display = Display.codeframe,
-    project: configFile = findConfigFile("tsconfig.json") || findConfigFile("jsconfig.json")
+    project: configFile = findRootConfigFile("tsconfig.json") || findRootConfigFile("jsconfig.json")
   } = opts;
   if (!configFile)
     throw new Error("Could not find tsconfig.json or jsconfig.json");
-  const { host, parsedCommandLine, getProcessor } = createCompilerHost(
-    configFile,
-    emit ? requiredTSCompilerOptionsEmit : requiredTSCompilerOptionsNoEmit
-  );
   const formatSettings = import_tsserverlibrary.default.getDefaultFormatCodeSettings(
-    ((_a = host.getNewLine) == null ? void 0 : _a.call(host)) || import_tsserverlibrary.default.sys.newLine
+    import_tsserverlibrary.default.sys.newLine
   );
   const report = {
     out: [],
     display,
-    hasErrors: false,
-    formatSettings
+    formatSettings,
+    hasErrors: false
   };
-  const program = import_tsserverlibrary.default.createProgram({
-    host,
-    options: parsedCommandLine.options,
-    rootNames: parsedCommandLine.fileNames,
-    projectReferences: parsedCommandLine.projectReferences
-  });
-  reportDiagnostics(report, import_tsserverlibrary.default.getPreEmitDiagnostics(program));
-  if (!report.hasErrors) {
-    const typeChecker = program.getTypeChecker();
-    const printer = import_tsserverlibrary.default.createPrinter({
-      noEmitHelpers: true,
-      removeComments: true
-    });
-    const emitResult = program.emit(
-      void 0,
-      emit ? (fileName, _text, writeByteOrderMark, onError, sourceFiles, data) => {
-        const processor = (sourceFiles == null ? void 0 : sourceFiles.length) === 1 && getProcessor(sourceFiles[0].fileName) || void 0;
-        if (processor) {
-          const [sourceFile] = sourceFiles;
-          const processorExt = (0, import_language_tools.getExt)(sourceFile.fileName);
-          const inDtsExt = processorExt + import_tsserverlibrary.default.Extension.Dts;
-          const inJsExt = processorExt + import_tsserverlibrary.default.Extension.Js;
-          const inExt = fileName.endsWith(inDtsExt) ? inDtsExt : fileName.endsWith(inJsExt) ? inJsExt : void 0;
-          if (!inExt) {
-            throw new Error("Unexpected file extension: " + fileName);
-          }
-          const isDts = inExt === inDtsExt;
-          let outFileName = fileName;
-          if ((0, import_language_tools.isDefinitionFile)(sourceFile.fileName)) {
-            if (!isDts)
-              return;
-            outFileName = fileName.slice(0, -inExt.length) + processorExt;
-          } else {
-            if (isDts && program.getSourceFile(
-              `${sourceFile.fileName.slice(
-                0,
-                -processorExt.length
-              )}.d${processorExt}`
-            )) {
-              return;
-            }
-            outFileName = fileName.slice(0, -inExt.length) + (isDts ? ".d" : "") + processorExt;
-          }
-          const extracted = extractCache.get(
-            program.getSourceFile(sourceFile.fileName)
-          );
-          const printContext = {
-            extracted,
-            printer,
-            typeChecker,
-            sourceFile,
-            formatSettings
-          };
-          host.writeFile(
-            outFileName,
-            isDts ? processor.printTypes(printContext).code : processor.print(printContext).code,
-            writeByteOrderMark,
-            onError,
-            sourceFiles,
-            data
-          );
-        } else {
-          host.writeFile(
-            fileName,
-            _text,
-            writeByteOrderMark,
-            onError,
-            sourceFiles,
-            data
-          );
-        }
-      } : void 0,
-      void 0,
-      false
-    );
-    reportDiagnostics(report, emitResult.diagnostics);
-  }
-  const lineSep = report.formatSettings.newLineCharacter + report.formatSettings.newLineCharacter;
-  console.log(report.out.join(lineSep));
-  process.exitCode = report.hasErrors ? 1 : 0;
-}
-function createCompilerHost(configFile, compilerOptions) {
-  const getProcessor = (fileName) => {
-    const ext = (0, import_language_tools.getExt)(fileName);
-    return ext ? processors[ext] : void 0;
-  };
-  const resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, _containingSourceFile, _reusedNames) => {
-    return moduleLiterals.map((moduleLiteral) => {
-      return import_tsserverlibrary.default.bundlerModuleNameResolver(
-        moduleLiteral.text,
-        containingFile,
-        options,
-        host,
-        resolutionCache,
-        redirectedReference
-      );
-    });
-  };
-  const parsedCommandLine = import_tsserverlibrary.default.parseJsonConfigFileContent(
-    configFile && import_tsserverlibrary.default.readConfigFile(configFile, import_tsserverlibrary.default.sys.readFile).config || defaultTSConfig,
-    import_tsserverlibrary.default.sys,
-    currentDirectory,
-    compilerOptions,
-    configFile,
+  const extraExtensions = import_language_tools.Processors.extensions.map((extension) => ({
+    extension,
+    isMixedContent: false,
+    scriptKind: import_tsserverlibrary.default.ScriptKind.Deferred
+  }));
+  const solutionHost = import_tsserverlibrary.default.createSolutionBuilderHost(
     void 0,
-    import_language_tools.Processors.extensions.map((extension) => ({
-      extension,
-      isMixedContent: false,
-      scriptKind: import_tsserverlibrary.default.ScriptKind.Deferred
-    }))
-  );
-  const host = {
-    getDefaultLibFileName: import_tsserverlibrary.default.getDefaultLibFilePath,
-    writeFile: import_tsserverlibrary.default.sys.writeFile,
-    getCurrentDirectory: import_tsserverlibrary.default.sys.getCurrentDirectory,
-    getDirectories: import_tsserverlibrary.default.sys.getDirectories,
-    getCanonicalFileName: (fileName) => import_tsserverlibrary.default.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
-    getNewLine: () => import_tsserverlibrary.default.sys.newLine,
-    useCaseSensitiveFileNames: () => import_tsserverlibrary.default.sys.useCaseSensitiveFileNames,
-    fileExists: import_tsserverlibrary.default.sys.fileExists,
-    readFile: import_tsserverlibrary.default.sys.readFile,
-    readDirectory: (path3, extensions, exclude, include, depth) => import_tsserverlibrary.default.sys.readDirectory(
-      path3,
-      extensions == null ? void 0 : extensions.concat(import_language_tools.Processors.extensions),
-      exclude,
-      include,
-      depth
-    ),
-    resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
-      let normalModuleLiterals = moduleLiterals;
-      let resolvedModules;
-      for (let i = 0; i < moduleLiterals.length; i++) {
-        const moduleLiteral = moduleLiterals[i];
-        const moduleName = moduleLiteral.text;
-        const processor = moduleName[0] !== "*" ? getProcessor(moduleName) : void 0;
-        if (processor) {
-          let isExternalLibraryImport = false;
-          let resolvedFileName;
-          if (fsPathReg.test(moduleName)) {
-            resolvedFileName = import_path.default.resolve(containingFile, "..", moduleName);
-          } else {
-            const [, nodeModuleName, relativeModulePath] = modulePartsReg.exec(moduleName);
-            const { resolvedModule } = import_tsserverlibrary.default.nodeModuleNameResolver(
-              `${nodeModuleName}/package.json`,
-              containingFile,
-              options,
-              host,
-              resolutionCache,
-              redirectedReference
-            );
-            if (resolvedModule) {
-              isExternalLibraryImport = true;
-              resolvedFileName = import_path.default.join(
-                resolvedModule.resolvedFileName,
-                "..",
-                relativeModulePath
+    (rootNames, options, compilerHost, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+      if (!compilerHost) {
+        throw new Error("Expected compilerHost to be provided.");
+      }
+      const resolutionCache = import_tsserverlibrary.default.createModuleResolutionCache(
+        currentDirectory,
+        getCanonicalFileName,
+        options
+      );
+      const { readDirectory = import_tsserverlibrary.default.sys.readDirectory } = compilerHost;
+      compilerHost.readDirectory = (path3, extensions, exclude, include, depth) => readDirectory(
+        path3,
+        extensions == null ? void 0 : extensions.concat(import_language_tools.Processors.extensions),
+        exclude,
+        include,
+        depth
+      );
+      compilerHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options2, _containingSourceFile, _reusedNames) => {
+        let normalModuleLiterals = moduleLiterals;
+        let resolvedModules;
+        for (let i = 0; i < moduleLiterals.length; i++) {
+          const moduleLiteral = moduleLiterals[i];
+          const moduleName = moduleLiteral.text;
+          const processor = moduleName[0] !== "*" ? getProcessor(moduleName) : void 0;
+          if (processor) {
+            let isExternalLibraryImport = false;
+            let resolvedFileName;
+            if (fsPathReg.test(moduleName)) {
+              resolvedFileName = import_path.default.resolve(containingFile, "..", moduleName);
+            } else {
+              const [, nodeModuleName, relativeModulePath] = modulePartsReg.exec(moduleName);
+              const { resolvedModule } = import_tsserverlibrary.default.nodeModuleNameResolver(
+                `${nodeModuleName}/package.json`,
+                containingFile,
+                options2,
+                compilerHost,
+                resolutionCache,
+                redirectedReference
               );
+              if (resolvedModule) {
+                isExternalLibraryImport = true;
+                resolvedFileName = import_path.default.join(
+                  resolvedModule.resolvedFileName,
+                  "..",
+                  relativeModulePath
+                );
+              }
             }
-          }
-          if (!resolvedModules) {
-            resolvedModules = [];
-            normalModuleLiterals = [];
-            for (let j = 0; j < i; j++) {
-              resolvedModules.push(void 0);
-              normalModuleLiterals.push(moduleLiterals[j]);
-            }
-          }
-          if (resolvedFileName) {
-            if ((0, import_language_tools.isDefinitionFile)(resolvedFileName)) {
-              if (!host.fileExists(resolvedFileName)) {
-                resolvedFileName = void 0;
+            if (!resolvedModules) {
+              resolvedModules = [];
+              normalModuleLiterals = [];
+              for (let j = 0; j < i; j++) {
+                resolvedModules.push(void 0);
+                normalModuleLiterals.push(moduleLiterals[j]);
               }
-            } else {
-              const ext = (0, import_language_tools.getExt)(resolvedFileName);
-              const definitionFile = `${resolvedFileName.slice(
-                0,
-                -ext.length
-              )}.d${ext}`;
-              if (host.fileExists(definitionFile)) {
-                resolvedFileName = definitionFile;
-              } else if (!host.fileExists(resolvedFileName)) {
-                resolvedFileName = void 0;
+            }
+            if (resolvedFileName) {
+              if ((0, import_language_tools.isDefinitionFile)(resolvedFileName)) {
+                if (!compilerHost.fileExists(resolvedFileName)) {
+                  resolvedFileName = void 0;
+                }
+              } else {
+                const ext = (0, import_language_tools.getExt)(resolvedFileName);
+                const definitionFile = `${resolvedFileName.slice(
+                  0,
+                  -ext.length
+                )}.d${ext}`;
+                if (compilerHost.fileExists(definitionFile)) {
+                  resolvedFileName = definitionFile;
+                } else if (!compilerHost.fileExists(resolvedFileName)) {
+                  resolvedFileName = void 0;
+                }
               }
             }
+            resolvedModules.push({
+              resolvedModule: resolvedFileName ? {
+                resolvedFileName,
+                extension: processor.getScriptExtension(resolvedFileName),
+                isExternalLibraryImport
+              } : void 0
+            });
+          } else if (resolvedModules) {
+            resolvedModules.push(void 0);
+            normalModuleLiterals.push(moduleLiteral);
           }
-          resolvedModules.push({
-            resolvedModule: resolvedFileName ? {
-              resolvedFileName,
-              extension: processor.getScriptExtension(resolvedFileName),
-              isExternalLibraryImport
-            } : void 0
-          });
-        } else if (resolvedModules) {
-          resolvedModules.push(void 0);
-          normalModuleLiterals.push(moduleLiteral);
         }
-      }
-      const normalResolvedModules = normalModuleLiterals.length ? resolveModuleNameLiterals(
-        normalModuleLiterals,
-        containingFile,
-        redirectedReference,
-        options,
-        containingSourceFile,
-        reusedNames
-      ) : void 0;
-      if (resolvedModules) {
-        if (normalResolvedModules) {
-          for (let i = 0, j = 0; i < resolvedModules.length; i++) {
-            if (!resolvedModules[i]) {
-              resolvedModules[i] = normalResolvedModules[j++];
+        const normalResolvedModules = normalModuleLiterals.length ? normalModuleLiterals.map((moduleLiteral) => {
+          return import_tsserverlibrary.default.bundlerModuleNameResolver(
+            moduleLiteral.text,
+            containingFile,
+            options2,
+            compilerHost,
+            resolutionCache,
+            redirectedReference
+          );
+        }) : void 0;
+        if (resolvedModules) {
+          if (normalResolvedModules) {
+            for (let i = 0, j = 0; i < resolvedModules.length; i++) {
+              if (!resolvedModules[i]) {
+                resolvedModules[i] = normalResolvedModules[j++];
+              }
             }
           }
+          return resolvedModules;
+        } else {
+          return normalResolvedModules;
         }
-        return resolvedModules;
-      } else {
-        return normalResolvedModules;
-      }
-    },
-    getSourceFile: (fileName, languageVersion) => {
-      const processor = getProcessor(fileName);
-      const code = host.readFile(fileName);
-      if (code !== void 0) {
-        if (processor) {
-          const extracted = processor.extract(fileName, code);
-          const sourceFile = import_tsserverlibrary.default.createSourceFile(
+      };
+      const getSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+      compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+        const processor = getProcessor(fileName);
+        const code = compilerHost.readFile(fileName);
+        if (code !== void 0) {
+          if (processor) {
+            const extracted = processor.extract(fileName, code);
+            const extractedCode = extracted.toString();
+            const sourceFile = import_tsserverlibrary.default.createSourceFile(
+              fileName,
+              extractedCode,
+              languageVersion,
+              true,
+              processor.getScriptKind(fileName)
+            );
+            sourceFile.version = import_crypto.default.createHash("md5").update(extractedCode).digest("hex");
+            extractCache.set(sourceFile, extracted);
+            return sourceFile;
+          }
+          return getSourceFile(
             fileName,
-            extracted.toString(),
             languageVersion,
-            true,
-            processor.getScriptKind(fileName)
+            onError,
+            shouldCreateNewSourceFile
           );
-          extractCache.set(sourceFile, extracted);
-          return sourceFile;
         }
-        return import_tsserverlibrary.default.createSourceFile(fileName, code, languageVersion, true);
-      }
-    }
-  };
-  const resolutionCache = import_tsserverlibrary.default.createModuleResolutionCache(
-    currentDirectory,
-    host.getCanonicalFileName,
-    parsedCommandLine.options
+      };
+      const builderProgram = import_tsserverlibrary.default.createEmitAndSemanticDiagnosticsBuilderProgram(
+        rootNames,
+        options,
+        compilerHost,
+        oldProgram,
+        configFileParsingDiagnostics,
+        projectReferences
+      );
+      const program = builderProgram.getProgram();
+      const builderEmit = builderProgram.emit.bind(builderProgram);
+      builderProgram.emit = (targetSourceFile, _writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+        let writeFile = _writeFile;
+        if (_writeFile) {
+          const typeChecker = program.getTypeChecker();
+          const printer = import_tsserverlibrary.default.createPrinter({
+            noEmitHelpers: true,
+            removeComments: true
+          });
+          writeFile = (fileName, _text, writeByteOrderMark, onError, sourceFiles, data) => {
+            const processor = (sourceFiles == null ? void 0 : sourceFiles.length) === 1 && getProcessor(sourceFiles[0].fileName) || void 0;
+            if (processor) {
+              const [sourceFile] = sourceFiles;
+              const processorExt = (0, import_language_tools.getExt)(sourceFile.fileName);
+              const inDtsExt = processorExt + import_tsserverlibrary.default.Extension.Dts;
+              const inJsExt = processorExt + import_tsserverlibrary.default.Extension.Js;
+              const inExt = fileName.endsWith(inDtsExt) ? inDtsExt : fileName.endsWith(inJsExt) ? inJsExt : void 0;
+              if (!inExt) {
+                const msg = `Unexpected file extension: ${fileName}`;
+                if (onError) {
+                  onError(msg);
+                  return;
+                }
+                throw new Error(msg);
+              }
+              const isDts = inExt === inDtsExt;
+              let outFileName = fileName;
+              if ((0, import_language_tools.isDefinitionFile)(sourceFile.fileName)) {
+                if (!isDts)
+                  return;
+                outFileName = fileName.slice(0, -inExt.length) + processorExt;
+              } else {
+                if (isDts && program.getSourceFile(
+                  `${sourceFile.fileName.slice(
+                    0,
+                    -processorExt.length
+                  )}.d${processorExt}`
+                )) {
+                  return;
+                }
+                outFileName = fileName.slice(0, -inExt.length) + (isDts ? ".d" : "") + processorExt;
+              }
+              const extracted = extractCache.get(
+                program.getSourceFile(sourceFile.fileName)
+              );
+              const printContext = {
+                extracted,
+                printer,
+                typeChecker,
+                sourceFile,
+                formatSettings: report.formatSettings
+              };
+              _writeFile(
+                outFileName,
+                isDts ? processor.printTypes(printContext).code : processor.print(printContext).code,
+                writeByteOrderMark,
+                onError,
+                sourceFiles,
+                data
+              );
+            } else {
+              _writeFile(
+                fileName,
+                _text,
+                writeByteOrderMark,
+                onError,
+                sourceFiles,
+                data
+              );
+            }
+          };
+        }
+        return builderEmit(
+          targetSourceFile,
+          writeFile,
+          cancellationToken,
+          emitOnlyDtsFiles,
+          customTransformers
+        );
+      };
+      return builderProgram;
+    },
+    (diag) => reportDiagnostic(report, diag)
   );
   const processors = import_language_tools.Processors.create({
     ts: import_tsserverlibrary.default,
-    host,
-    configFile
+    configFile,
+    host: solutionHost
   });
-  parsedCommandLine.fileNames = [
-    ...new Set(
-      parsedCommandLine.fileNames.concat(
-        Object.values(processors).map((processor) => {
-          var _a;
-          return (_a = processor.getRootNames) == null ? void 0 : _a.call(processor);
-        }).flat().filter(Boolean)
-      )
-    )
-  ];
-  return {
-    host,
-    parsedCommandLine,
-    getProcessor
+  const getProcessor = (fileName) => {
+    const ext = (0, import_language_tools.getExt)(fileName);
+    return ext ? processors[ext] : void 0;
   };
-}
-function reportDiagnostics(report, diags) {
-  for (const diag of diags) {
-    if (diag.file && diag.start !== void 0) {
-      const extracted = extractCache.get(diag.file);
-      let code = diag.file.text;
-      let loc;
-      if (extracted) {
-        loc = extracted.sourceLocationAt(
-          diag.start,
-          diag.start + (diag.length || 0)
-        );
-        code = extracted.parsed.code;
-        if (!loc)
-          continue;
-      } else {
-        const start = import_tsserverlibrary.default.getLineAndCharacterOfPosition(diag.file, diag.start);
-        const end = diag.length ? import_tsserverlibrary.default.getLineAndCharacterOfPosition(
-          diag.file,
-          diag.start + diag.length
-        ) : start;
-        loc = {
-          start,
-          end
-        };
-      }
-      if (diag.category === import_tsserverlibrary.default.DiagnosticCategory.Error) {
-        report.hasErrors = true;
+  solutionHost.getParsedCommandLine = (fileName) => {
+    var _a, _b;
+    const parsedCommandLine = import_tsserverlibrary.default.getParsedCommandLineOfConfigFile(
+      fileName,
+      requiredTSCompilerOptions,
+      {
+        ...import_tsserverlibrary.default.sys,
+        onUnRecoverableConfigFileDiagnostic(diag) {
+          reportDiagnostic(report, diag);
+        }
+      },
+      void 0,
+      void 0,
+      extraExtensions
+    );
+    if (!parsedCommandLine)
+      return;
+    const finalRootNames = new Set(parsedCommandLine.fileNames);
+    for (const name in processors) {
+      const rootNames = (_b = (_a = processors[name]).getRootNames) == null ? void 0 : _b.call(_a);
+      if (rootNames) {
+        for (const rootName of rootNames) {
+          finalRootNames.add(rootName);
+        }
       }
-      const diagMessage = flattenDiagnosticMessage(
-        diag.messageText,
-        report.display,
-        report.formatSettings.newLineCharacter
-      );
-      report.out.push(
-        `${import_kleur.default.cyan(
-          import_path.default.relative(currentDirectory, diag.file.fileName)
-        )}:${import_kleur.default.yellow(loc.start.line + 1)}:${import_kleur.default.yellow(
-          loc.start.character + 1
-        )} - ${coloredDiagnosticCategory(diag.category)} ${import_kleur.default.dim(
-          `TS${diag.code}`
-        )}${report.formatSettings.newLineCharacter}${report.display === Display.codeframe ? report.formatSettings.newLineCharacter + formatCodeFrameMessage(code, loc, diagMessage) : diagMessage}`
+    }
+    parsedCommandLine.fileNames = [...finalRootNames];
+    return parsedCommandLine;
+  };
+  import_tsserverlibrary.default.createSolutionBuilder(solutionHost, [configFile], {}).build();
+  process.exitCode = report.hasErrors ? 1 : 0;
+  console.log(
+    report.out.join(
+      report.formatSettings.newLineCharacter + report.formatSettings.newLineCharacter
+    )
+  );
+}
+function reportDiagnostic(report, diag) {
+  if (diag.file && diag.start !== void 0) {
+    const extracted = extractCache.get(diag.file);
+    let code = diag.file.text;
+    let loc;
+    if (extracted) {
+      loc = extracted.sourceLocationAt(
+        diag.start,
+        diag.start + (diag.length || 0)
       );
+      code = extracted.parsed.code;
+      if (!loc)
+        return;
     } else {
-      if (diag.category === import_tsserverlibrary.default.DiagnosticCategory.Error) {
-        report.hasErrors = true;
-      }
-      report.out.push(
-        flattenDiagnosticMessage(
-          diag.messageText,
-          report.display,
-          report.formatSettings.newLineCharacter
-        )
-      );
-    }
-    if (diag.relatedInformation && report.display === Display.codeframe) {
-      reportRelatedDiagnostics(report, diag.relatedInformation);
+      const start = import_tsserverlibrary.default.getLineAndCharacterOfPosition(diag.file, diag.start);
+      const end = diag.length ? import_tsserverlibrary.default.getLineAndCharacterOfPosition(diag.file, diag.start + diag.length) : start;
+      loc = {
+        start,
+        end
+      };
     }
+    const diagMessage = flattenDiagnosticMessage(
+      diag.messageText,
+      report.display,
+      report.formatSettings.newLineCharacter
+    );
+    report.out.push(
+      `${import_kleur.default.cyan(
+        import_path.default.relative(currentDirectory, diag.file.fileName)
+      )}:${import_kleur.default.yellow(loc.start.line + 1)}:${import_kleur.default.yellow(
+        loc.start.character + 1
+      )} - ${coloredDiagnosticCategory(diag.category)} ${import_kleur.default.dim(
+        `TS${diag.code}`
+      )}${report.formatSettings.newLineCharacter}${report.display === Display.codeframe ? report.formatSettings.newLineCharacter + formatCodeFrameMessage(code, loc, diagMessage) : diagMessage}`
+    );
+  } else {
+    report.out.push(
+      flattenDiagnosticMessage(
+        diag.messageText,
+        report.display,
+        report.formatSettings.newLineCharacter
+      )
+    );
+  }
+  if (!report.hasErrors && diag.category === import_tsserverlibrary.default.DiagnosticCategory.Error) {
+    report.hasErrors = true;
+  }
+  if (diag.relatedInformation && report.display === Display.codeframe) {
+    reportRelatedDiagnostics(report, diag.relatedInformation);
   }
 }
 function reportRelatedDiagnostics(report, diags) {
   for (const diag of diags) {
-    if (diag.file && diag.start) {
-      const extracted = extractCache.get(diag.file);
-      let code = diag.file.text;
-      let loc;
-      if (extracted) {
-        loc = extracted.sourceLocationAt(
-          diag.start,
-          diag.start + (diag.length || 0)
-        );
-        code = extracted.parsed.code;
-      } else {
-        const start = import_tsserverlibrary.default.getLineAndCharacterOfPosition(diag.file, diag.start);
-        const end = diag.length ? import_tsserverlibrary.default.getLineAndCharacterOfPosition(
-          diag.file,
-          diag.start + diag.length
-        ) : start;
-        loc = {
-          start,
-          end
-        };
-      }
-      if (loc) {
-        report.out.push(
-          formatCodeFrameMessage(
-            code,
-            loc,
-            `${flattenDiagnosticMessage(
-              diag.messageText,
-              report.display,
-              report.formatSettings.newLineCharacter
-            )} @ ${import_path.default.relative(currentDirectory, diag.file.fileName)}:${loc.start.line + 1}:${loc.start.character + 1}`
-          )
-        );
-      }
-    } else {
-      report.out.push(
-        flattenDiagnosticMessage(
-          diag.messageText,
-          report.display,
-          report.formatSettings.newLineCharacter
-        )
-      );
-    }
+    reportDiagnostic(report, diag);
   }
 }
 function formatCodeFrameMessage(code, loc, message) {
@@ -501,7 +449,7 @@ function coloredDiagnosticCategory(category) {
       );
   }
 }
-function findConfigFile(name) {
+function findRootConfigFile(name) {
   return import_tsserverlibrary.default.findConfigFile(currentDirectory, import_tsserverlibrary.default.sys.fileExists, name);
 }
 
@@ -510,12 +458,10 @@ var args = (0, import_arg.default)(
   {
     "--project": String,
     "--display": String,
-    "--emit": Boolean,
     "--help": Boolean,
     "--version": Boolean,
     "-p": "--project",
     "-d": "--display",
-    "-e": "--emit",
     "-h": "--help",
     "-v": "--version"
   },
@@ -541,11 +487,6 @@ ${import_kleur2.default.bold("Options:")}
   )}       Set the display type for error output. Choices: ${import_kleur2.default.green(
     `"codeframe"`
   )} or ${import_kleur2.default.green(`"condensed"`)} (default: ${import_kleur2.default.green(`"codeframe"`)})
-  ${import_kleur2.default.yellow(
-    "-e, --emit"
-  )}                 Emit .js, .d.ts, .marko (with types stripped), and .d.marko files (default: ${import_kleur2.default.magenta(
-    "false"
-  )})
   ${import_kleur2.default.yellow(
     "-v, --version"
   )}              Display the CLI version, Marko version, and TypeScript version
@@ -577,7 +518,6 @@ For more information, visit ${import_kleur2.default.blue(
   );
 } else {
   const {
-    "--emit": emit,
     "--display": display = process.env.CI ? Display.condensed : Display.codeframe
   } = args;
   let { "--project": project } = args;
@@ -588,7 +528,7 @@ For more information, visit ${import_kleur2.default.blue(
     }
   }
   checkDisplay(display);
-  run({ project, display, emit });
+  run({ project, display });
 }
 function checkDisplay(display) {
   if (display && Display[display] === void 0) {

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@marko/type-check",
   "description": "A CLI to type check Marko projects",
-  "version": "0.0.18",
+  "version": "1.0.1",
   "bugs": "https://github.com/marko-js/language-server/issues/new?template=Bug_report.md",
   "dependencies": {
-    "@babel/code-frame": "^7.22.5",
-    "@marko/language-tools": "^2.1.4",
+    "@babel/code-frame": "^7.22.13",
+    "@marko/language-tools": "^2.1.5",
     "arg": "^5.0.2",
     "kleur": "^4.1.5",
     "strip-json-comments": "^3.1.1",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   },
   "devDependencies": {
-    "@types/babel__code-frame": "^7.0.3"
+    "@types/babel__code-frame": "^7.0.4"
   },
   "files": [
     "dist",