@marko/type-check 0.0.1

package/README.md

@@ -0,0 +1,72 @@
+# Marko Type Check (@marko/type-check)
+
+A CLI for running type checks on .marko, .ts, and .js files.
+
+## Installation
+
+```
+npm install --save-dev @marko/type-check
+```
+
+## Usage
+
+Use the `marko-type-check` or `mtc` command followed by options to run type checks on your project files:
+
+```terminal
+marko-type-check [options]
+
+# or with the shorthand
+mtc [options]
+```
+
+## Options
+
+| Option           | Alias | Description                                                            | Default Value                      |
+| ---------------- | ----- | ---------------------------------------------------------------------- | ---------------------------------- |
+| --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         |                                    |
+
+## Examples
+
+### Run type check with the default tsconfig.json file:
+
+```
+marko-type-check
+```
+
+### Run type check with a custom jsconfig.json file and condensed error output:
+
+```
+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?
+
+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.
+
+### What is a `.d.marko` file?
+
+A `.d.marko` files is similar to a `.d.ts` file. All script content in the file will be processed as if the Marko script-lang was typescript and the Marko-VSCode plugin and this CLI will both prefer loading a `.d.marko` over an adjacent `.marko` file. The `.d.marko` files output by this tool will strip out any runtime code such that only type information is in the `.d.marko` output.
+
+### Does this replace `tsc`?
+
+Yes this replaces `tsc` since in order to provide proper type checking for `.marko` files the `.ts` and `.js` files must be processed as well.
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guidelines](CONTRIBUTING.md) for more information on how to contribute.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_fs = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_module = require("module");
+var import_arg = __toESM(require("arg"));
+var import_kleur2 = __toESM(require("kleur"));
+
+// src/run.ts
+var import_path = __toESM(require("path"));
+var import_tsserverlibrary = __toESM(require("typescript/lib/tsserverlibrary"));
+var import_kleur = __toESM(require("kleur"));
+var import_code_frame = require("@babel/code-frame");
+var import_language_tools = require("@marko/language-tools");
+var Display = {
+  codeframe: "codeframe",
+  condensed: "condensed"
+};
+var currentDirectory = import_tsserverlibrary.default.sys.getCurrentDirectory();
+var fsPathReg = /^(?:[./\\]|[A-Z]:)/i;
+var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
+var extractCache = /* @__PURE__ */ new WeakMap();
+var requiredTSCompilerOptions = {
+  module: import_tsserverlibrary.default.ModuleKind.ESNext,
+  moduleResolution: import_tsserverlibrary.default.ModuleResolutionKind.Bundler,
+  allowJs: 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")
+  } = 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
+  );
+  const report = {
+    out: [],
+    display,
+    hasErrors: false,
+    formatSettings
+  };
+  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,
+    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 moduleName = moduleLiterals[i].text;
+        const process2 = moduleName[0] !== "*" ? getProcessor(moduleName) : void 0;
+        if (process2) {
+          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.resolveModuleName(
+              `${nodeModuleName}/package.json`,
+              containingFile,
+              options,
+              host,
+              resolutionCache
+            );
+            if (resolvedModule) {
+              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;
+              }
+            } 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;
+              }
+            }
+          }
+          resolvedModules.push({
+            resolvedModule: resolvedFileName ? {
+              resolvedFileName,
+              extension: process2.getScriptExtension(resolvedFileName),
+              isExternalLibraryImport: false
+            } : void 0
+          });
+        } else if (resolvedModules) {
+          resolvedModules.push(void 0);
+        }
+      }
+      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++];
+            }
+          }
+        }
+        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(
+            fileName,
+            extracted.toString(),
+            languageVersion,
+            true,
+            processor.getScriptKind(fileName)
+          );
+          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 processors = import_language_tools.Processors.create({
+    ts: import_tsserverlibrary.default,
+    host,
+    configFile
+  });
+  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
+  };
+}
+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;
+      }
+      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 {
+      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);
+    }
+  }
+}
+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
+        )
+      );
+    }
+  }
+}
+function formatCodeFrameMessage(code, loc, message) {
+  return (0, import_code_frame.codeFrameColumns)(
+    code,
+    {
+      start: {
+        line: loc.start.line + 1,
+        column: loc.start.character + 1
+      },
+      end: {
+        line: loc.end.line + 1,
+        column: loc.end.character + 1
+      }
+    },
+    {
+      highlightCode: true,
+      message
+    }
+  );
+}
+function flattenDiagnosticMessage(message, display, newLine) {
+  const str = import_tsserverlibrary.default.flattenDiagnosticMessageText(message, newLine);
+  const strWithNewlines = str.replace(/(?:\r?\n)[ \t]+/g, newLine);
+  return str === strWithNewlines ? str : (display === Display.codeframe ? newLine : "") + strWithNewlines;
+}
+function coloredDiagnosticCategory(category) {
+  switch (category) {
+    case import_tsserverlibrary.default.DiagnosticCategory.Error:
+      return import_kleur.default.red("error");
+    case import_tsserverlibrary.default.DiagnosticCategory.Warning:
+      return import_kleur.default.yellow("warning");
+    case import_tsserverlibrary.default.DiagnosticCategory.Message:
+      return import_kleur.default.blue("message");
+    case import_tsserverlibrary.default.DiagnosticCategory.Suggestion:
+      return import_kleur.default.magenta("suggestion");
+    default:
+      return import_kleur.default.red(
+        (import_tsserverlibrary.default.DiagnosticCategory[category] || "unknown").toLocaleLowerCase()
+      );
+  }
+}
+function findConfigFile(name) {
+  return import_tsserverlibrary.default.findConfigFile(currentDirectory, import_tsserverlibrary.default.sys.fileExists, name);
+}
+
+// src/cli.ts
+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"
+  },
+  { permissive: false, argv: process.argv.slice(2) }
+);
+if (args["--help"]) {
+  console.log(`${import_kleur2.default.bold(
+    `Usage: ${import_kleur2.default.cyan("marko-type-check")} ${import_kleur2.default.magenta(
+      `[options]`
+    )} | ${import_kleur2.default.cyan("mtc")} ${import_kleur2.default.magenta(`[options]`)}
+`
+  )}
+A command-line interface for running type checks on .marko, .ts, and .js files.
+
+${import_kleur2.default.bold("Options:")}
+  ${import_kleur2.default.yellow("-p, --project")} ${import_kleur2.default.magenta(
+    "<path>"
+  )}       Path to the tsconfig or jsconfig file (default: ${import_kleur2.default.green(
+    `"./tsconfig.json"`
+  )} or ${import_kleur2.default.green(`"./jsconfig.json"`)})
+  ${import_kleur2.default.yellow("-d, --display")} ${import_kleur2.default.magenta(
+    "<type>"
+  )}       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
+  ${import_kleur2.default.yellow("-h, --help")}                 Display this help text
+
+${import_kleur2.default.bold("Examples:")}
+  ${import_kleur2.default.cyan("marko-type-check")} --project ./tsconfig.json
+  ${import_kleur2.default.cyan("mtc")} -p ./jsconfig.json -d condensed -e
+
+For more information, visit ${import_kleur2.default.blue(
+    "https://github.com/marko-js/language-server/tree/main/packages/marko-type-check"
+  )}
+`);
+} else if (args["--version"]) {
+  const require2 = (0, import_module.createRequire)(__dirname);
+  const getPackageVersion = (id) => {
+    try {
+      return `${id} v${require2(`${id}/package.json`).version}`;
+    } catch {
+      return `${id} unknown version`;
+    }
+  };
+  console.log(
+    `marko-type-check v${require2("../package.json").version} (${[
+      getPackageVersion("marko"),
+      getPackageVersion("@marko/compiler"),
+      getPackageVersion("typescript")
+    ].join(", ")})`
+  );
+} else {
+  const {
+    "--emit": emit,
+    "--display": display = process.env.CI ? Display.condensed : Display.codeframe
+  } = args;
+  let { "--project": project } = args;
+  if (project) {
+    project = import_path2.default.resolve(process.cwd(), project);
+    if (!import_fs.default.existsSync(project)) {
+      throw new Error(`Project path does not exist: ${project}`);
+    }
+  }
+  checkDisplay(display);
+  run({ project, display, emit });
+}
+function checkDisplay(display) {
+  if (display && Display[display] === void 0) {
+    throw new Error(
+      `Invalid display option, must be one of: ${Object.values(Display).join(
+        ", "
+      )}`
+    );
+  }
+}

package/dist/run.d.ts

@@ -0,0 +1,11 @@
+export declare const Display: {
+    readonly codeframe: "codeframe";
+    readonly condensed: "condensed";
+};
+export type Display = (typeof Display)[keyof typeof Display];
+export interface Options {
+    project?: string;
+    display?: Display;
+    emit?: boolean;
+}
+export default function run(opts: Options): void;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@marko/type-check",
+  "description": "A CLI to type check Marko projects",
+  "version": "0.0.1",
+  "bugs": "https://github.com/marko-js/language-server/issues/new?template=Bug_report.md",
+  "dependencies": {
+    "@babel/code-frame": "^7.18.6",
+    "@marko/language-tools": "^2.0.0",
+    "arg": "^5.0.2",
+    "kleur": "^4.1.5",
+    "strip-json-comments": "^5.0.0",
+    "typescript": "5.0.2"
+  },
+  "devDependencies": {
+    "@types/babel__code-frame": "^7.0.3"
+  },
+  "files": [
+    "dist",
+    "!**/__tests__",
+    "!**/*.tsbuildinfo"
+  ],
+  "homepage": "https://github.com/marko-js/language-server/tree/main/packages/type-check/README.md",
+  "keywords": [
+    "type-check",
+    "marko",
+    "tsc",
+    "typescript",
+    "tools"
+  ],
+  "license": "MIT",
+  "bin": {
+    "marko-type-check": "dist/cli.js",
+    "mtc": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marko-js/language-server/tree/main/packages/type-check"
+  },
+  "scripts": {
+    "build": "tsc -b && tsx build.mts"
+  }
+}