astro 2.9.7 → 3.0.0-beta.0

package/dist/cli/check/index.d.ts

@@ -1,78 +1,2 @@
-/// <reference types="node" />
-import { AstroCheck } from '@astrojs/language-server';
-import fs from 'node:fs';
-import type { Arguments as Flags } from 'yargs-parser';
-import type { AstroSettings } from '../../@types/astro';
-import type { LogOptions } from '../../core/logger/core.js';
-import type { syncInternal } from '../../core/sync';
-export type CheckPayload = {
-    /**
-     * Flags passed via CLI
-     */
-    flags: Flags;
-};
-/**
- *
- * Types of response emitted by the checker
- */
-export declare enum CheckResult {
-    /**
-     * Operation finished without errors
-     */
-    ExitWithSuccess = 0,
-    /**
-     * Operation finished with errors
-     */
-    ExitWithError = 1,
-    /**
-     * The consumer should not terminate the operation
-     */
-    Listen = 2
-}
-/**
- * Checks `.astro` files for possible errors.
- *
- * If the `--watch` flag is provided, the command runs indefinitely and provides diagnostics
- * when `.astro` files are modified.
- *
- * Every time an astro files is modified, content collections are also generated.
- *
- * @param {CheckPayload} options Options passed {@link AstroChecker}
- * @param {Flags} options.flags Flags coming from the CLI
- */
-export declare function check({ flags }: CheckPayload): Promise<AstroChecker | undefined>;
-type CheckerConstructor = {
-    diagnosticChecker: AstroCheck;
-    isWatchMode: boolean;
-    syncInternal: typeof syncInternal;
-    settings: Readonly<AstroSettings>;
-    logging: Readonly<LogOptions>;
-    fileSystem: typeof fs;
-};
-/**
- * Responsible to check files - classic or watch mode - and report diagnostics.
- *
- * When in watch mode, the class does a whole check pass, and then starts watching files.
- * When a change occurs to an `.astro` file, the checker builds content collections again and lint all the `.astro` files.
- */
-export declare class AstroChecker {
-    #private;
-    constructor({ diagnosticChecker, isWatchMode, syncInternal, settings, fileSystem, logging, }: CheckerConstructor);
-    /**
-     * Check all `.astro` files once and then finishes the operation.
-     */
-    check(): Promise<CheckResult>;
-    /**
-     * Check all `.astro` files and then start watching for changes.
-     */
-    watch(): Promise<CheckResult>;
-    /**
-     * Stops the watch. It terminates the inner server.
-     */
-    stop(): Promise<void>;
-    /**
-     * Whether the checker should run in watch mode
-     */
-    get isWatchMode(): boolean;
-}
-export {};
+import type { Arguments } from 'yargs-parser';
+export declare function check(flags: Arguments): Promise<boolean | void>;

package/dist/cli/check/index.js

@@ -1,282 +1,30 @@
-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 { resolveConfig } from "../../core/config/config.js";
-import { createNodeLogging } from "../../core/config/logging.js";
-import { createSettings } from "../../core/config/settings.js";
-import { debug, info } from "../../core/logger/core.js";
-import { printHelp } from "../../core/messages.js";
-import { eventCliSession, telemetry } from "../../events/index.js";
-import { runHookConfigSetup } from "../../integrations/index.js";
-import { flagsToAstroInlineConfig } from "../flags.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({ 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 inlineConfig = flagsToAstroInlineConfig(flags);
-  const logging = createNodeLogging(inlineConfig);
-  const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "check");
-  telemetry.record(eventCliSession("check", userConfig, flags));
-  const settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
-  const checkFlags = parseFlags(flags);
-  if (checkFlags.watch) {
-    info(logging, "check", "Checking files in watch mode");
-  } else {
-    info(logging, "check", "Checking files");
-  }
-  const { syncInternal } = 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({
-    syncInternal,
-    settings,
-    fileSystem: fs,
+import path from "node:path";
+import { error, info } from "../../core/logger/core.js";
+import { createLoggingFromFlags } from "../flags.js";
+import { getPackage } from "../install-package.js";
+async function check(flags) {
+  const logging = createLoggingFromFlags(flags);
+  const getPackageOpts = { skipAsk: flags.yes || flags.y, cwd: flags.root };
+  const checkPackage = await getPackage(
+    "@astrojs/check",
     logging,
-    diagnosticChecker,
-    isWatchMode: checkFlags.watch
-  });
-}
-class AstroChecker {
-  #diagnosticsChecker;
-  #shouldWatch;
-  #syncInternal;
-  #settings;
-  #logging;
-  #fs;
-  #watcher;
-  #filesCount;
-  #updateDiagnostics;
-  constructor({
-    diagnosticChecker,
-    isWatchMode,
-    syncInternal,
-    settings,
-    fileSystem,
-    logging
-  }) {
-    this.#diagnosticsChecker = diagnosticChecker;
-    this.#shouldWatch = isWatchMode;
-    this.#syncInternal = syncInternal;
-    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 syncSettings = await runHookConfigSetup({
-      settings: this.#settings,
-      logging: this.#logging,
-      command: "build"
-    });
-    const processExit = await this.#syncInternal(syncSettings, {
-      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("-")} `)
+    getPackageOpts,
+    ["typescript"]
+  );
+  const typescript = await getPackage("typescript", logging, getPackageOpts);
+  if (!checkPackage || !typescript) {
+    error(
+      logging,
+      "check",
+      "The `@astrojs/check` and `typescript` packages are required for this command to work. Please manually install them into your project and try again."
     );
+    return;
   }
-  /**
-   * 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
-  };
+  const { check: checker, parseArgsAsCheckConfig } = checkPackage;
+  const config = parseArgsAsCheckConfig(process.argv);
+  info(logging, "check", `Getting diagnostics for Astro files in ${path.resolve(config.root)}...`);
+  return await checker(config);
 }
 export {
-  AstroChecker,
-  CheckResult,
   check
 };

package/dist/cli/dev/index.js

@@ -9,7 +9,7 @@ async function dev({ flags }) {
       usage: "[...flags]",
       tables: {
         Flags: [
-          ["--port", `Specify which port to run on. Defaults to 3000.`],
+          ["--port", `Specify which port to run on. Defaults to 4321.`],
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
           ["--host <custom-address>", `Expose on a network IP address at <custom-address>`],
           ["--open", "Automatically open the app in the browser on server start"],

package/dist/cli/index.js

@@ -57,7 +57,6 @@ function resolveCommand(flags) {
   return "help";
 }
 async function runCommand(cmd, flags) {
-  var _a;
   switch (cmd) {
     case "help":
       await printAstroHelp();
@@ -77,7 +76,7 @@ async function runCommand(cmd, flags) {
     }
     case "telemetry": {
       const { update } = await import("./telemetry/index.js");
-      const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
+      const subcommand = flags._[3]?.toString();
       await update(subcommand, { flags });
       return;
     }
@@ -120,18 +119,13 @@ async function runCommand(cmd, flags) {
     }
     case "check": {
       const { check } = await import("./check/index.js");
-      const checkServer = await check({ flags });
-      if (checkServer) {
-        if (checkServer.isWatchMode) {
-          await checkServer.watch();
-          return await new Promise(() => {
-          });
-        } else {
-          const checkResult = await checkServer.check();
-          return process.exit(checkResult);
-        }
+      const checkServer = await check(flags);
+      if (flags.watch) {
+        return await new Promise(() => {
+        });
+      } else {
+        return process.exit(checkServer ? 1 : 0);
       }
-      return;
     }
     case "sync": {
       const { sync } = await import("./sync/index.js");

package/dist/cli/info/index.js

@@ -5,7 +5,6 @@ import { resolveConfig } from "../../core/config/index.js";
 import { ASTRO_VERSION } from "../../core/constants.js";
 import { flagsToAstroInlineConfig } from "../flags.js";
 async function printInfo({ flags }) {
-  var _a;
   const inlineConfig = flagsToAstroInlineConfig(flags);
   const packageManager = await whichPm(process.cwd());
   let adapter = "Couldn't determine.";
@@ -17,16 +16,16 @@ async function printInfo({ flags }) {
   }
   try {
     const { userConfig } = await resolveConfig(inlineConfig, "info");
-    if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
+    if (userConfig.adapter?.name) {
       adapter = userConfig.adapter.name;
     }
     if (userConfig.integrations) {
-      integrations = ((userConfig == null ? void 0 : userConfig.integrations) ?? []).filter(Boolean).flat().map((i) => i == null ? void 0 : i.name);
+      integrations = (userConfig?.integrations ?? []).filter(Boolean).flat().map((i) => i?.name);
     }
   } catch (_e) {
   }
   console.log();
-  const packageManagerName = (packageManager == null ? void 0 : packageManager.name) ?? "Couldn't determine.";
+  const packageManagerName = packageManager?.name ?? "Couldn't determine.";
   printRow("Astro version", `v${ASTRO_VERSION}`);
   printRow("Package manager", packageManagerName);
   printRow("Platform", platform());

package/dist/cli/install-package.d.ts

@@ -0,0 +1,7 @@
+import { type LogOptions } from '../core/logger/core.js';
+type GetPackageOptions = {
+    skipAsk?: boolean;
+    cwd?: string;
+};
+export declare function getPackage<T>(packageName: string, logging: LogOptions, options: GetPackageOptions, otherDeps?: string[]): Promise<T | undefined>;
+export {};

package/dist/cli/install-package.js

@@ -0,0 +1,102 @@
+import boxen from "boxen";
+import { execa } from "execa";
+import { bold, cyan, dim, magenta } from "kleur/colors";
+import { createRequire } from "node:module";
+import ora from "ora";
+import prompts from "prompts";
+import whichPm from "which-pm";
+import { debug, info } from "../core/logger/core.js";
+async function getPackage(packageName, logging, options, otherDeps = []) {
+  const require2 = createRequire(options.cwd ?? process.cwd());
+  let packageImport;
+  try {
+    require2.resolve(packageName);
+    packageImport = await import(packageName);
+  } catch (e) {
+    info(
+      logging,
+      "",
+      `To continue, Astro requires the following dependency to be installed: ${bold(packageName)}.`
+    );
+    const result = await installPackage([packageName, ...otherDeps], options, logging);
+    if (result) {
+      packageImport = await import(packageName);
+    } else {
+      return void 0;
+    }
+  }
+  return packageImport;
+}
+function getInstallCommand(packages, packageManager) {
+  switch (packageManager) {
+    case "npm":
+      return { pm: "npm", command: "install", flags: [], dependencies: packages };
+    case "yarn":
+      return { pm: "yarn", command: "add", flags: [], dependencies: packages };
+    case "pnpm":
+      return { pm: "pnpm", command: "add", flags: [], dependencies: packages };
+    default:
+      return null;
+  }
+}
+async function installPackage(packageNames, options, logging) {
+  const cwd = options.cwd ?? process.cwd();
+  const packageManager = (await whichPm(cwd)).name ?? "npm";
+  const installCommand = getInstallCommand(packageNames, packageManager);
+  if (!installCommand) {
+    return false;
+  }
+  const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
+    "",
+    ...installCommand.flags
+  ].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
+  const message = `
+${boxen(coloredOutput, {
+    margin: 0.5,
+    padding: 0.5,
+    borderStyle: "round"
+  })}
+`;
+  info(
+    logging,
+    null,
+    `
+  ${magenta("Astro will run the following command:")}
+  ${dim(
+      "If you skip this step, you can always run it yourself later"
+    )}
+${message}`
+  );
+  let response;
+  if (options.skipAsk) {
+    response = true;
+  } else {
+    response = (await prompts({
+      type: "confirm",
+      name: "askToContinue",
+      message: "Continue?",
+      initial: true
+    })).askToContinue;
+  }
+  if (Boolean(response)) {
+    const spinner = ora("Installing dependencies...").start();
+    try {
+      await execa(
+        installCommand.pm,
+        [installCommand.command, ...installCommand.flags, ...installCommand.dependencies],
+        { cwd }
+      );
+      spinner.succeed();
+      return true;
+    } catch (err) {
+      debug("add", "Error installing dependencies", err);
+      spinner.fail();
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+export {
+  getPackage
+};

package/dist/cli/preview/index.js

@@ -3,7 +3,7 @@ import { printHelp } from "../../core/messages.js";
 import previewServer from "../../core/preview/index.js";
 import { flagsToAstroInlineConfig } from "../flags.js";
 async function preview({ flags }) {
-  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
+  if (flags?.help || flags?.h) {
     printHelp({
       commandName: "astro preview",
       usage: "[...flags]",

package/dist/cli/sync/index.js

@@ -2,7 +2,7 @@ import { printHelp } from "../../core/messages.js";
 import { sync as _sync } from "../../core/sync/index.js";
 import { flagsToAstroInlineConfig } from "../flags.js";
 async function sync({ flags }) {
-  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
+  if (flags?.help || flags?.h) {
     printHelp({
       commandName: "astro sync",
       usage: "[...flags]",

package/dist/content/runtime-assets.js

@@ -3,8 +3,7 @@ import { emitESMImage } from "../assets/utils/emitAsset.js";
 function createImage(pluginContext, entryFilePath) {
   return () => {
     return z.string().transform(async (imagePath, ctx) => {
-      var _a;
-      const resolvedFilePath = (_a = await pluginContext.resolve(imagePath, entryFilePath)) == null ? void 0 : _a.id;
+      const resolvedFilePath = (await pluginContext.resolve(imagePath, entryFilePath))?.id;
       const metadata = await emitESMImage(
         resolvedFilePath,
         pluginContext.meta.watchMode,

package/dist/content/runtime.js

@@ -112,8 +112,7 @@ function createGetDataEntryById({
   dataCollectionToEntryMap
 }) {
   return async function getDataEntryById(collection, id) {
-    var _a;
-    const lazyImport = (_a = dataCollectionToEntryMap[collection]) == null ? void 0 : _a[
+    const lazyImport = dataCollectionToEntryMap[collection]?.[
       /*TODO: filePathToIdMap*/
       id + ".json"
     ];
@@ -184,7 +183,6 @@ async function render({
   id,
   renderEntryImport
 }) {
-  var _a, _b;
   const UnexpectedRenderError = new AstroError({
     ...AstroErrorData.UnknownContentCollectionError,
     message: `Unexpected error while rendering ${String(collection)} \u2192 ${String(id)}.`
@@ -246,13 +244,13 @@ async function render({
     });
     return {
       Content,
-      headings: ((_a = propagationMod.getHeadings) == null ? void 0 : _a.call(propagationMod)) ?? [],
+      headings: propagationMod.getHeadings?.() ?? [],
       remarkPluginFrontmatter: propagationMod.frontmatter ?? {}
     };
   } else if (baseMod.Content && typeof baseMod.Content === "function") {
     return {
       Content: baseMod.Content,
-      headings: ((_b = baseMod.getHeadings) == null ? void 0 : _b.call(baseMod)) ?? [],
+      headings: baseMod.getHeadings?.() ?? [],
       remarkPluginFrontmatter: baseMod.frontmatter ?? {}
     };
   } else {

package/dist/content/server-listeners.js

@@ -87,7 +87,6 @@ function getTSConfigStatsWhenAllowJsFalse({
   contentPaths,
   settings
 }) {
-  var _a, _b;
   const isContentConfigJsFile = [".js", ".mjs"].some(
     (ext) => contentPaths.config.url.pathname.endsWith(ext)
   );
@@ -98,7 +97,7 @@ function getTSConfigStatsWhenAllowJsFalse({
   if (!tsConfigFileName)
     return;
   const contentConfigFileName = contentPaths.config.url.pathname.split(path.sep).pop();
-  const allowJSOption = (_b = (_a = inputConfig == null ? void 0 : inputConfig.config) == null ? void 0 : _a.compilerOptions) == null ? void 0 : _b.allowJs;
+  const allowJSOption = inputConfig?.config?.compilerOptions?.allowJs;
   const hasAllowJs = allowJSOption === true || tsConfigFileName === "jsconfig.json" && allowJSOption !== false;
   if (hasAllowJs)
     return;