astro 2.0.17 → 2.1.0

package/dist/cli/check/index.js

@@ -3,69 +3,208 @@ import glob from "fast-glob";
 import * as fs from "fs";
 import { bold, dim, red, yellow } from "kleur/colors";
 import { createRequire } from "module";
+import { join } from "node:path";
 import ora from "ora";
 import { fileURLToPath, pathToFileURL } from "url";
+import { debug, info } from "../../core/logger/core.js";
+import { printHelp } from "../../core/messages.js";
 import { printDiagnostic } from "./print.js";
-async function check(settings, { logging }) {
-  console.log(bold("astro check"));
+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(settings, { logging, flags }) {
+  if (flags.help || flags.h) {
+    printHelp({
+      commandName: "astro check",
+      usage: "[...flags]",
+      tables: {
+        Flags: [["--help (-h)", "See all available flags."]]
+      },
+      description: `Runs diagnostics against your project and reports errors to the console.`
+    });
+    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 syncRet = await syncCli(settings, { logging, fs });
-  if (syncRet === 1)
-    return syncRet;
   const root = settings.config.root;
-  const spinner = ora(` Getting diagnostics for Astro files in ${fileURLToPath(root)}\u2026`).start();
   const require2 = createRequire(import.meta.url);
-  let checker = new AstroCheck(
+  const diagnosticChecker = new AstroCheck(
     root.toString(),
-    require2.resolve("typescript/lib/tsserverlibrary.js", { paths: [root.toString()] })
+    require2.resolve("typescript/lib/tsserverlibrary.js", {
+      paths: [root.toString()]
+    })
   );
-  const filesCount = await openAllDocuments(root, [], checker);
-  let diagnostics = await checker.getDiagnostics();
-  spinner.succeed();
-  let result = {
-    errors: 0,
-    warnings: 0,
-    hints: 0
-  };
-  diagnostics.forEach((diag) => {
-    diag.diagnostics.forEach((d) => {
-      console.log(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 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;
+  }
+  async check() {
+    return await this.#checkAllFiles(true);
+  }
+  async watch() {
+    await this.#checkAllFiles(true);
+    await this.#watch();
+    return 2 /* Listen */;
+  }
+  async stop() {
+    var _a;
+    await ((_a = this.#watcher) == null ? void 0 : _a.close());
+  }
+  get isWatchMode() {
+    return this.#shouldWatch;
+  }
+  async #openDocuments() {
+    this.#filesCount = await openAllDocuments(
+      this.#settings.config.root,
+      [],
+      this.#diagnosticsChecker
+    );
+  }
+  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);
+  }
+  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();
     });
-  });
-  console.log(
-    [
-      bold(`Result (${filesCount} file${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"}
+    this.#watcher.on("change", (file) => {
+      this.#addDocument(file);
+      this.#checkForDiagnostics();
+    });
+    this.#watcher.on("unlink", (file) => {
+      this.#diagnosticsChecker.removeDocument(file);
+      this.#filesCount -= 1;
+      this.#checkForDiagnostics();
+    });
+  }
+  #addDocument(filePath) {
+    const text = fs.readFileSync(filePath, "utf-8");
+    this.#diagnosticsChecker.upsertDocument({
+      uri: pathToFileURL(filePath).toString(),
+      text
+    });
+  }
+  #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(`
+      ].join(`
 ${dim("-")} `)
-  );
-  const exitCode = result.errors ? 1 : 0;
-  return exitCode;
+    );
+  }
+  #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", {
+  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(),
@@ -74,6 +213,13 @@ async function openAllDocuments(workspaceUri, filePathsToIgnore, checker) {
   }
   return files.length;
 }
+function parseFlags(flags) {
+  return {
+    watch: flags.watch ?? false
+  };
+}
 export {
+  AstroChecker,
+  CheckResult,
   check
 };

package/dist/cli/index.js

@@ -53,17 +53,18 @@ async function printVersion() {
 }
 function resolveCommand(flags) {
   const cmd = flags._[2];
-  if (cmd === "add")
-    return "add";
-  if (cmd === "sync")
-    return "sync";
-  if (cmd === "telemetry")
-    return "telemetry";
   if (flags.version)
     return "version";
-  else if (flags.help)
-    return "help";
-  const supportedCommands = /* @__PURE__ */ new Set(["dev", "build", "preview", "check", "docs"]);
+  const supportedCommands = /* @__PURE__ */ new Set([
+    "add",
+    "sync",
+    "telemetry",
+    "dev",
+    "build",
+    "preview",
+    "check",
+    "docs"
+  ]);
   if (supportedCommands.has(cmd)) {
     return cmd;
   }
@@ -109,6 +110,16 @@ async function runCommand(cmd, flags) {
     }
     case "docs": {
       telemetry.record(event.eventCliSession(cmd));
+      if (flags.help || flags.h) {
+        printHelp({
+          commandName: "astro docs",
+          tables: {
+            Flags: [["--help (-h)", "See all available flags."]]
+          },
+          description: `Launches the Astro Docs website directly from the terminal.`
+        });
+        return;
+      }
       return await openInBrowser("https://docs.astro.build/");
     }
     case "telemetry": {
@@ -154,21 +165,33 @@ async function runCommand(cmd, flags) {
     }
     case "build": {
       const { default: build } = await import("../core/build/index.js");
-      return await build(settings, { ...flags, logging, telemetry, teardownCompiler: true });
+      return await build(settings, { flags, logging, telemetry, teardownCompiler: true });
     }
     case "check": {
-      const ret = await check(settings, { logging });
-      return process.exit(ret);
+      const checkServer = await check(settings, { flags, logging });
+      if (checkServer) {
+        if (checkServer.isWatchMode) {
+          await checkServer.watch();
+          return await new Promise(() => {
+          });
+        } else {
+          let checkResult = await checkServer.check();
+          return process.exit(checkResult);
+        }
+      }
     }
     case "sync": {
       const { syncCli } = await import("../core/sync/index.js");
-      const ret = await syncCli(settings, { logging, fs });
-      return process.exit(ret);
+      const result = await syncCli(settings, { logging, fs, flags });
+      return process.exit(result);
     }
     case "preview": {
       const { default: preview } = await import("../core/preview/index.js");
-      const server = await preview(settings, { logging, telemetry });
-      return await server.closed();
+      const server = await preview(settings, { logging, telemetry, flags });
+      if (server) {
+        return await server.closed();
+      }
+      return;
     }
   }
   throw new Error(`Error running ${cmd} -- no command found.`);

package/dist/cli/telemetry.js

@@ -1,7 +1,7 @@
 import * as msg from "../core/messages.js";
 async function update(subcommand, { flags, telemetry }) {
   const isValid = ["enable", "disable", "reset"].includes(subcommand);
-  if (flags.help || !isValid) {
+  if (flags.help || flags.h || !isValid) {
     msg.printHelp({
       commandName: "astro telemetry",
       usage: "[command]",

package/dist/content/consts.d.ts

@@ -1,4 +1,3 @@
-export declare const contentFileExts: string[];
 export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
 export declare const CONTENT_FLAG = "astroContent";
 export declare const VIRTUAL_MODULE_ID = "astro:content";

package/dist/content/consts.js

@@ -1,4 +1,3 @@
-const contentFileExts = [".md", ".mdx"];
 const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
 const CONTENT_FLAG = "astroContent";
 const VIRTUAL_MODULE_ID = "astro:content";
@@ -13,6 +12,5 @@ export {
   PROPAGATED_ASSET_FLAG,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER,
-  VIRTUAL_MODULE_ID,
-  contentFileExts
+  VIRTUAL_MODULE_ID
 };

package/dist/content/internal.d.ts

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+import { type Metadata } from '../assets/utils/metadata.js';
 type GlobResult = Record<string, () => Promise<any>>;
 type CollectionToEntryMap = Record<string, GlobResult>;
 export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
@@ -34,4 +36,9 @@ export declare function createGetEntryBySlug({ getCollection, collectionToRender
         remarkPluginFrontmatter: any;
     }>;
 } | undefined>;
+export declare function createImage(options: {
+    assetsDir: string;
+}): () => z.ZodEffects<z.ZodString, (Metadata & {
+    __astro_asset: true;
+}) | undefined, string>;
 export {};

package/dist/content/internal.js

@@ -1,3 +1,5 @@
+import { z } from "zod";
+import { imageMetadata } from "../assets/utils/metadata.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { prependForwardSlash } from "../core/path.js";
 import {
@@ -23,7 +25,7 @@ function createCollectionToGlobResultMap({
       continue;
     const collection = segments[0];
     const entryId = segments.slice(1).join("/");
-    collectionToGlobResultMap[collection] ?? (collectionToGlobResultMap[collection] = {});
+    collectionToGlobResultMap[collection] ??= {};
     collectionToGlobResultMap[collection][entryId] = globResult[key];
   }
   return collectionToGlobResultMap;
@@ -98,7 +100,7 @@ async function render({
   id,
   collectionToRenderEntryMap
 }) {
-  var _a;
+  var _a, _b;
   const UnexpectedRenderError = new AstroError({
     ...AstroErrorData.UnknownContentCollectionError,
     message: `Unexpected error while rendering ${String(collection)} \u2192 ${String(id)}.`
@@ -153,12 +155,32 @@ async function render({
   });
   return {
     Content,
-    headings: mod.getHeadings(),
-    remarkPluginFrontmatter: mod.frontmatter
+    headings: ((_b = mod.getHeadings) == null ? void 0 : _b.call(mod)) ?? [],
+    remarkPluginFrontmatter: mod.frontmatter ?? {}
   };
 }
+function createImage(options) {
+  return () => {
+    if (options.assetsDir === "undefined") {
+      throw new Error("Enable `experimental.assets` in your Astro config to use image()");
+    }
+    return z.string().transform(async (imagePath) => {
+      const fullPath = new URL(imagePath, options.assetsDir);
+      return await getImageMetadata(fullPath);
+    });
+  };
+}
+async function getImageMetadata(imagePath) {
+  const meta = await imageMetadata(imagePath);
+  if (!meta) {
+    return void 0;
+  }
+  delete meta.orientation;
+  return { ...meta, __astro_asset: true };
+}
 export {
   createCollectionToGlobResultMap,
   createGetCollection,
-  createGetEntryBySlug
+  createGetEntryBySlug,
+  createImage
 };

package/dist/content/template/virtual-mod.d.mts

@@ -1,3 +1,4 @@
 export function defineCollection(config: any): any;
 export const getCollection: any;
 export const getEntryBySlug: any;
+export const image: any;

package/dist/content/types-generator.js

@@ -8,6 +8,7 @@ import { info, warn } from "../core/logger/core.js";
 import { isRelativePath } from "../core/path.js";
 import { CONTENT_TYPES_FILE } from "./consts.js";
 import {
+  getContentEntryExts,
   getContentPaths,
   getEntryInfo,
   getEntrySlug,
@@ -27,9 +28,10 @@ async function createContentTypesGenerator({
 }) {
   const contentTypes = {};
   const contentPaths = getContentPaths(settings.config, fs);
+  const contentEntryExts = getContentEntryExts(settings);
   let events = [];
   let debounceTimeout;
-  const contentTypesBase = await fs.promises.readFile(contentPaths.typesTemplate, "utf-8");
+  const typeTemplateContent = await fs.promises.readFile(contentPaths.typesTemplate, "utf-8");
   async function init() {
     if (!fs.existsSync(contentPaths.contentDir)) {
       return { typesGenerated: false, reason: "no-content-dir" };
@@ -77,7 +79,7 @@ async function createContentTypesGenerator({
       }
       return { shouldGenerateTypes: true };
     }
-    const fileType = getEntryType(fileURLToPath(event.entry), contentPaths);
+    const fileType = getEntryType(fileURLToPath(event.entry), contentPaths, contentEntryExts);
     if (fileType === "ignored") {
       return { shouldGenerateTypes: false };
     }
@@ -204,8 +206,9 @@ async function createContentTypesGenerator({
         fs,
         contentTypes,
         contentPaths,
-        contentTypesBase,
-        contentConfig: observable.status === "loaded" ? observable.config : void 0
+        typeTemplateContent,
+        contentConfig: observable.status === "loaded" ? observable.config : void 0,
+        contentEntryTypes: settings.contentEntryTypes
       });
       if (observable.status === "loaded" && ["info", "warn"].includes(logLevel)) {
         warnNonexistentCollections({
@@ -231,7 +234,7 @@ async function parseSlug({
 }) {
   const rawContents = await fs.promises.readFile(event.entry, "utf-8");
   const { data: frontmatter } = parseFrontmatter(rawContents, fileURLToPath(event.entry));
-  return getEntrySlug({ ...entryInfo, data: frontmatter });
+  return getEntrySlug({ ...entryInfo, unvalidatedSlug: frontmatter.slug });
 }
 function setEntry(contentTypes, collectionKey, entryKey, slug) {
   contentTypes[collectionKey][entryKey] = { slug };
@@ -243,7 +246,8 @@ async function writeContentFiles({
   fs,
   contentPaths,
   contentTypes,
-  contentTypesBase,
+  typeTemplateContent,
+  contentEntryTypes,
   contentConfig
 }) {
   let contentTypesStr = "";
@@ -256,6 +260,9 @@ async function writeContentFiles({
     for (const entryKey of entryKeys) {
       const entryMetadata = contentTypes[collectionKey][entryKey];
       const dataType = (collectionConfig == null ? void 0 : collectionConfig.schema) ? `InferEntrySchema<${collectionKey}>` : "any";
+      const renderType = `{ render(): Render[${JSON.stringify(
+        path.extname(JSON.parse(entryKey))
+      )}] }`;
       const slugType = JSON.stringify(entryMetadata.slug);
       contentTypesStr += `${entryKey}: {
   id: ${entryKey},
@@ -263,7 +270,7 @@ async function writeContentFiles({
   body: string,
   collection: ${collectionKey},
   data: ${dataType}
-},
+} & ${renderType},
 `;
     }
     contentTypesStr += `},
@@ -280,12 +287,20 @@ async function writeContentFiles({
   if (configPathRelativeToCacheDir.endsWith(".ts")) {
     configPathRelativeToCacheDir = configPathRelativeToCacheDir.replace(/\.ts$/, "");
   }
-  contentTypesBase = contentTypesBase.replace("// @@ENTRY_MAP@@", contentTypesStr);
-  contentTypesBase = contentTypesBase.replace(
+  for (const contentEntryType of contentEntryTypes) {
+    if (contentEntryType.contentModuleTypes) {
+      typeTemplateContent = contentEntryType.contentModuleTypes + "\n" + typeTemplateContent;
+    }
+  }
+  typeTemplateContent = typeTemplateContent.replace("// @@ENTRY_MAP@@", contentTypesStr);
+  typeTemplateContent = typeTemplateContent.replace(
     "'@@CONTENT_CONFIG_TYPE@@'",
     contentConfig ? `typeof import(${JSON.stringify(configPathRelativeToCacheDir)})` : "never"
   );
-  await fs.promises.writeFile(new URL(CONTENT_TYPES_FILE, contentPaths.cacheDir), contentTypesBase);
+  await fs.promises.writeFile(
+    new URL(CONTENT_TYPES_FILE, contentPaths.cacheDir),
+    typeTemplateContent
+  );
 }
 function warnNonexistentCollections({
   contentConfig,

package/dist/content/utils.d.ts

@@ -34,16 +34,9 @@ export declare const contentConfigParser: z.ZodObject<{
 }>;
 export type CollectionConfig = z.infer<typeof collectionConfigParser>;
 export type ContentConfig = z.infer<typeof contentConfigParser>;
-type Entry = {
-    id: string;
-    collection: string;
-    slug: string;
-    data: any;
-    body: string;
-    _internal: {
-        rawData: string;
-        filePath: string;
-    };
+type EntryInternal = {
+    rawData: string;
+    filePath: string;
 };
 export type EntryInfo = {
     id: string;
@@ -53,15 +46,24 @@ export type EntryInfo = {
 export declare const msg: {
     collectionConfigMissing: (collection: string) => string;
 };
-export declare function getEntrySlug({ id, collection, slug, data: unparsedData, }: Pick<Entry, 'id' | 'collection' | 'slug' | 'data'>): string;
-export declare function getEntryData(entry: Entry, collectionConfig: CollectionConfig): Promise<any>;
+export declare function extractFrontmatterAssets(data: Record<string, any>): string[];
+export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }: EntryInfo & {
+    unvalidatedSlug?: unknown;
+}): string;
+export declare function getEntryData(entry: EntryInfo & {
+    unvalidatedData: Record<string, unknown>;
+    _internal: EntryInternal;
+}, collectionConfig: CollectionConfig): Promise<{
+    [x: string]: unknown;
+}>;
+export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
 export declare class NoCollectionError extends Error {
 }
 export declare function getEntryInfo(params: Pick<ContentPaths, 'contentDir'> & {
     entry: URL;
     allowFilesOutsideCollection?: true;
 }): EntryInfo;
-export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>): 'content' | 'config' | 'ignored' | 'unsupported';
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[]): 'content' | 'config' | 'ignored' | 'unsupported';
 /**
  * Match YAML exception handling from Astro core errors
  * @see 'astro/src/core/errors.ts'
@@ -100,6 +102,7 @@ export type ContentObservable = Observable<ContentCtx>;
 export declare function contentObservable(initialCtx: ContentCtx): ContentObservable;
 export type ContentPaths = {
     contentDir: URL;
+    assetsDir: URL;
     cacheDir: URL;
     typesTemplate: URL;
     virtualModTemplate: URL;