🎉 initiate project *astro_rewrite*

node_modules/astro/dist/cli/check/index.js

@@ -0,0 +1,270 @@
+import {
+  AstroCheck,
+  DiagnosticSeverity
+} from "@astrojs/language-server";
+import glob from "fast-glob";
+import { bold, dim, red, yellow } from "kleur/colors";
+import { createRequire } from "module";
+import fs from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import ora from "ora";
+import { debug, info } from "../../core/logger/core.js";
+import { printHelp } from "../../core/messages.js";
+import { loadSettings } from "../load-settings.js";
+import { printDiagnostic } from "./print.js";
+var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
+  CheckResult2[CheckResult2["ExitWithSuccess"] = 0] = "ExitWithSuccess";
+  CheckResult2[CheckResult2["ExitWithError"] = 1] = "ExitWithError";
+  CheckResult2[CheckResult2["Listen"] = 2] = "Listen";
+  return CheckResult2;
+})(CheckResult || {});
+const ASTRO_GLOB_PATTERN = "**/*.astro";
+async function check({ logging, flags }) {
+  if (flags.help || flags.h) {
+    printHelp({
+      commandName: "astro check",
+      usage: "[...flags]",
+      tables: {
+        Flags: [
+          ["--watch", "Watch Astro files for changes and re-run checks."],
+          ["--help (-h)", "See all available flags."]
+        ]
+      },
+      description: `Runs diagnostics against your project and reports errors to the console.`
+    });
+    return;
+  }
+  const settings = await loadSettings({ cmd: "check", flags, logging });
+  if (!settings)
+    return;
+  const checkFlags = parseFlags(flags);
+  if (checkFlags.watch) {
+    info(logging, "check", "Checking files in watch mode");
+  } else {
+    info(logging, "check", "Checking files");
+  }
+  const { syncCli } = await import("../../core/sync/index.js");
+  const root = settings.config.root;
+  const require2 = createRequire(import.meta.url);
+  const diagnosticChecker = new AstroCheck(
+    root.toString(),
+    require2.resolve("typescript/lib/tsserverlibrary.js", {
+      paths: [root.toString()]
+    })
+  );
+  return new AstroChecker({
+    syncCli,
+    settings,
+    fileSystem: fs,
+    logging,
+    diagnosticChecker,
+    isWatchMode: checkFlags.watch
+  });
+}
+class AstroChecker {
+  #diagnosticsChecker;
+  #shouldWatch;
+  #syncCli;
+  #settings;
+  #logging;
+  #fs;
+  #watcher;
+  #filesCount;
+  #updateDiagnostics;
+  constructor({
+    diagnosticChecker,
+    isWatchMode,
+    syncCli,
+    settings,
+    fileSystem,
+    logging
+  }) {
+    this.#diagnosticsChecker = diagnosticChecker;
+    this.#shouldWatch = isWatchMode;
+    this.#syncCli = syncCli;
+    this.#logging = logging;
+    this.#settings = settings;
+    this.#fs = fileSystem;
+    this.#filesCount = 0;
+  }
+  /**
+   * Check all `.astro` files once and then finishes the operation.
+   */
+  async check() {
+    return await this.#checkAllFiles(true);
+  }
+  /**
+   * Check all `.astro` files and then start watching for changes.
+   */
+  async watch() {
+    await this.#checkAllFiles(true);
+    await this.#watch();
+    return 2 /* Listen */;
+  }
+  /**
+   * Stops the watch. It terminates the inner server.
+   */
+  async stop() {
+    var _a;
+    await ((_a = this.#watcher) == null ? void 0 : _a.close());
+  }
+  /**
+   * Whether the checker should run in watch mode
+   */
+  get isWatchMode() {
+    return this.#shouldWatch;
+  }
+  async #openDocuments() {
+    this.#filesCount = await openAllDocuments(
+      this.#settings.config.root,
+      [],
+      this.#diagnosticsChecker
+    );
+  }
+  /**
+   * Lint all `.astro` files, and report the result in console. Operations executed, in order:
+   * 1. Compile content collections.
+   * 2. Optionally, traverse the file system for `.astro` files and saves their paths.
+   * 3. Get diagnostics for said files and print the result in console.
+   *
+   * @param openDocuments Whether the operation should open all `.astro` files
+   */
+  async #checkAllFiles(openDocuments) {
+    const processExit = await this.#syncCli(this.#settings, {
+      logging: this.#logging,
+      fs: this.#fs
+    });
+    if (processExit === 1)
+      return processExit;
+    let spinner = ora(
+      ` Getting diagnostics for Astro files in ${fileURLToPath(this.#settings.config.root)}\u2026`
+    ).start();
+    if (openDocuments) {
+      await this.#openDocuments();
+    }
+    let diagnostics = await this.#diagnosticsChecker.getDiagnostics();
+    spinner.succeed();
+    let brokenDownDiagnostics = this.#breakDownDiagnostics(diagnostics);
+    this.#logDiagnosticsSeverity(brokenDownDiagnostics);
+    return brokenDownDiagnostics.errors > 0 ? 1 /* ExitWithError */ : 0 /* ExitWithSuccess */;
+  }
+  #checkForDiagnostics() {
+    clearTimeout(this.#updateDiagnostics);
+    this.#updateDiagnostics = setTimeout(async () => await this.#checkAllFiles(false), 500);
+  }
+  /**
+   * This function is responsible to attach events to the server watcher
+   */
+  async #watch() {
+    const { default: chokidar } = await import("chokidar");
+    this.#watcher = chokidar.watch(
+      join(fileURLToPath(this.#settings.config.root), ASTRO_GLOB_PATTERN),
+      {
+        ignored: ["**/node_modules/**"],
+        ignoreInitial: true
+      }
+    );
+    this.#watcher.on("add", (file) => {
+      this.#addDocument(file);
+      this.#filesCount += 1;
+      this.#checkForDiagnostics();
+    });
+    this.#watcher.on("change", (file) => {
+      this.#addDocument(file);
+      this.#checkForDiagnostics();
+    });
+    this.#watcher.on("unlink", (file) => {
+      this.#diagnosticsChecker.removeDocument(file);
+      this.#filesCount -= 1;
+      this.#checkForDiagnostics();
+    });
+  }
+  /**
+   * Add a document to the diagnostics checker
+   * @param filePath Path to the file
+   */
+  #addDocument(filePath) {
+    const text = fs.readFileSync(filePath, "utf-8");
+    this.#diagnosticsChecker.upsertDocument({
+      uri: pathToFileURL(filePath).toString(),
+      text
+    });
+  }
+  /**
+   * Logs the result of the various diagnostics
+   *
+   * @param result Result emitted by AstroChecker.#breakDownDiagnostics
+   */
+  #logDiagnosticsSeverity(result) {
+    info(
+      this.#logging,
+      "diagnostics",
+      [
+        bold(`Result (${this.#filesCount} file${this.#filesCount === 1 ? "" : "s"}): `),
+        bold(red(`${result.errors} ${result.errors === 1 ? "error" : "errors"}`)),
+        bold(yellow(`${result.warnings} ${result.warnings === 1 ? "warning" : "warnings"}`)),
+        dim(`${result.hints} ${result.hints === 1 ? "hint" : "hints"}
+`)
+      ].join(`
+${dim("-")} `)
+    );
+  }
+  /**
+   * It loops through all diagnostics and break down diagnostics that are errors, warnings or hints.
+   */
+  #breakDownDiagnostics(diagnostics) {
+    let result = {
+      errors: 0,
+      warnings: 0,
+      hints: 0
+    };
+    diagnostics.forEach((diag) => {
+      diag.diagnostics.forEach((d) => {
+        info(this.#logging, "diagnostics", `
+ ${printDiagnostic(diag.fileUri, diag.text, d)}`);
+        switch (d.severity) {
+          case DiagnosticSeverity.Error: {
+            result.errors++;
+            break;
+          }
+          case DiagnosticSeverity.Warning: {
+            result.warnings++;
+            break;
+          }
+          case DiagnosticSeverity.Hint: {
+            result.hints++;
+            break;
+          }
+        }
+      });
+    });
+    return result;
+  }
+}
+async function openAllDocuments(workspaceUri, filePathsToIgnore, checker) {
+  const files = await glob(ASTRO_GLOB_PATTERN, {
+    cwd: fileURLToPath(workspaceUri),
+    ignore: ["node_modules/**"].concat(filePathsToIgnore.map((ignore) => `${ignore}/**`)),
+    absolute: true
+  });
+  for (const file of files) {
+    debug("check", `Adding file ${file} to the list of files to check.`);
+    const text = fs.readFileSync(file, "utf-8");
+    checker.upsertDocument({
+      uri: pathToFileURL(file).toString(),
+      text
+    });
+  }
+  return files.length;
+}
+function parseFlags(flags) {
+  return {
+    watch: flags.watch ?? false
+  };
+}
+export {
+  AstroChecker,
+  CheckResult,
+  check
+};