astro 1.6.0 → 1.6.2

package/dist/cli/index.js

@@ -14,13 +14,13 @@ import {
 } from "../core/config/index.js";
 import { ASTRO_VERSION } from "../core/constants.js";
 import devServer from "../core/dev/index.js";
-import { collectErrorMetadata } from "../core/errors.js";
+import { collectErrorMetadata } from "../core/errors/dev/index.js";
+import { createSafeError } from "../core/errors/index.js";
 import { debug, error, info } from "../core/logger/core.js";
 import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js";
 import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
 import { appendForwardSlash } from "../core/path.js";
 import preview from "../core/preview/index.js";
-import { createSafeError } from "../core/util.js";
 import * as event from "../events/index.js";
 import { eventConfigError, eventError, telemetry } from "../events/index.js";
 import { check } from "./check/index.js";

package/dist/core/build/index.js

@@ -8,7 +8,7 @@ import {
   runHookConfigSetup
 } from "../../integrations/index.js";
 import { createVite } from "../create-vite.js";
-import { fixViteErrorMessage } from "../errors.js";
+import { enhanceViteSSRError } from "../errors/dev/index.js";
 import { debug, info, levels, timerMessage } from "../logger/core.js";
 import { apply as applyPolyfill } from "../polyfill.js";
 import { RouteCache } from "../render/route-cache.js";
@@ -127,7 +127,7 @@ class AstroBuilder {
     try {
       await this.build(setupData);
     } catch (_err) {
-      throw fixViteErrorMessage(_err);
+      throw enhanceViteSSRError(_err);
     }
   }
   validateConfig() {

package/dist/core/build/static-build.js

@@ -92,6 +92,7 @@ async function ssrBuild(opts, internals, input) {
       emptyOutDir: false,
       manifest: false,
       outDir: fileURLToPath(out),
+      copyPublicDir: !ssr,
       rollupOptions: {
         ...(_a = viteConfig.build) == null ? void 0 : _a.rollupOptions,
         input: [],
@@ -105,7 +106,7 @@ async function ssrBuild(opts, internals, input) {
       },
       ssr: true,
       minify: false,
-      polyfillModulePreload: false,
+      modulePreload: { polyfill: false },
       reportCompressedSize: false
     },
     plugins: [
@@ -120,7 +121,6 @@ async function ssrBuild(opts, internals, input) {
       settings.config.output === "server" && vitePluginSSR(internals, settings.adapter),
       vitePluginAnalyzer(internals)
     ],
-    publicDir: ssr ? false : viteConfig.publicDir,
     envPrefix: "PUBLIC_",
     base: settings.config.base
   };

package/dist/core/compile/compile.js

@@ -1,7 +1,8 @@
 import { transform } from "@astrojs/compiler";
-import { AstroErrorCodes } from "../errors.js";
+import { AstroErrorCodes } from "../errors/codes.js";
+import { AggregateError, CompilerError } from "../errors/errors.js";
 import { prependForwardSlash } from "../path.js";
-import { AggregateError, resolvePath, viteID } from "../util.js";
+import { resolvePath, viteID } from "../util.js";
 import { createStylePreprocessor } from "./style.js";
 const configCache = /* @__PURE__ */ new WeakMap();
 async function compile({
@@ -28,23 +29,42 @@ async function compile({
       return resolvePath(specifier, filename);
     }
   }).catch((err) => {
-    err.code = err.code || AstroErrorCodes.UnknownCompilerError;
-    throw err;
+    throw new CompilerError({
+      errorCode: AstroErrorCodes.UnknownCompilerError,
+      message: err.message ?? "Unknown compiler error",
+      stack: err.stack,
+      location: {
+        file: filename
+      }
+    });
   }).then((result) => {
+    const compilerError = result.diagnostics.find(
+      (diag) => diag.severity === 1 && diag.code < 2e3
+    );
+    if (compilerError) {
+      throw new CompilerError({
+        errorCode: compilerError.code,
+        message: compilerError.text,
+        location: {
+          line: compilerError.location.line,
+          column: compilerError.location.column,
+          file: compilerError.location.file
+        },
+        hint: compilerError.hint ? compilerError.hint : void 0
+      });
+    }
     switch (cssTransformErrors.length) {
       case 0:
         return result;
       case 1: {
         let error = cssTransformErrors[0];
-        if (!error.code) {
-          error.code = AstroErrorCodes.UnknownCompilerCSSError;
+        if (!error.errorCode) {
+          error.errorCode = AstroErrorCodes.UnknownCompilerCSSError;
         }
         throw cssTransformErrors[0];
       }
       default: {
-        const aggregateError = new AggregateError(cssTransformErrors);
-        aggregateError.code = AstroErrorCodes.UnknownCompilerCSSError;
-        throw aggregateError;
+        throw new AggregateError({ ...cssTransformErrors[0], errors: cssTransformErrors });
       }
     }
   });

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.6.0";
+const ASTRO_VERSION = "1.6.2";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/create-vite.js

@@ -13,7 +13,7 @@ import legacyMarkdownVitePlugin from "../vite-plugin-markdown-legacy/index.js";
 import markdownVitePlugin from "../vite-plugin-markdown/index.js";
 import astroScriptsPlugin from "../vite-plugin-scripts/index.js";
 import astroScriptsPageSSRPlugin from "../vite-plugin-scripts/page-ssr.js";
-import { createCustomViteLogger } from "./errors.js";
+import { createCustomViteLogger } from "./errors/dev/index.js";
 import { resolveDependency } from "./util.js";
 const ALWAYS_NOEXTERNAL = /* @__PURE__ */ new Set([
   "astro",

package/dist/core/dev/index.js

@@ -54,7 +54,7 @@ async function dev(settings, options) {
       isRestart
     })
   );
-  const currentVersion = "1.6.0";
+  const currentVersion = "1.6.2";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/errors/codes.d.ts

@@ -0,0 +1,15 @@
+export declare enum AstroErrorCodes {
+    StaticRedirectNotAllowed = 2005,
+    UnavailableInSSR = 2006,
+    GenericRuntimeError = 3000,
+    CssSyntaxError = 4000,
+    CssUnknownError = 4001,
+    FailedToLoadModuleSSR = 5000,
+    ConfigError = 6000,
+    GenericMarkdownError = 7000,
+    MarkdownFrontmatterParseError = 7001,
+    UnknownCompilerError = 9000,
+    UnknownCompilerCSSError = 9001,
+    UnknownViteSSRError = 9002,
+    UnknownError = 9999
+}

package/dist/core/errors/codes.js

@@ -0,0 +1,19 @@
+var AstroErrorCodes = /* @__PURE__ */ ((AstroErrorCodes2) => {
+  AstroErrorCodes2[AstroErrorCodes2["StaticRedirectNotAllowed"] = 2005] = "StaticRedirectNotAllowed";
+  AstroErrorCodes2[AstroErrorCodes2["UnavailableInSSR"] = 2006] = "UnavailableInSSR";
+  AstroErrorCodes2[AstroErrorCodes2["GenericRuntimeError"] = 3e3] = "GenericRuntimeError";
+  AstroErrorCodes2[AstroErrorCodes2["CssSyntaxError"] = 4e3] = "CssSyntaxError";
+  AstroErrorCodes2[AstroErrorCodes2["CssUnknownError"] = 4001] = "CssUnknownError";
+  AstroErrorCodes2[AstroErrorCodes2["FailedToLoadModuleSSR"] = 5e3] = "FailedToLoadModuleSSR";
+  AstroErrorCodes2[AstroErrorCodes2["ConfigError"] = 6e3] = "ConfigError";
+  AstroErrorCodes2[AstroErrorCodes2["GenericMarkdownError"] = 7e3] = "GenericMarkdownError";
+  AstroErrorCodes2[AstroErrorCodes2["MarkdownFrontmatterParseError"] = 7001] = "MarkdownFrontmatterParseError";
+  AstroErrorCodes2[AstroErrorCodes2["UnknownCompilerError"] = 9e3] = "UnknownCompilerError";
+  AstroErrorCodes2[AstroErrorCodes2["UnknownCompilerCSSError"] = 9001] = "UnknownCompilerCSSError";
+  AstroErrorCodes2[AstroErrorCodes2["UnknownViteSSRError"] = 9002] = "UnknownViteSSRError";
+  AstroErrorCodes2[AstroErrorCodes2["UnknownError"] = 9999] = "UnknownError";
+  return AstroErrorCodes2;
+})(AstroErrorCodes || {});
+export {
+  AstroErrorCodes
+};

package/dist/core/errors/dev/index.d.ts

@@ -0,0 +1,2 @@
+export { collectErrorMetadata } from './utils.js';
+export { createCustomViteLogger, enhanceViteSSRError, getViteErrorPayload } from './vite.js';

package/dist/core/errors/dev/index.js

@@ -0,0 +1,8 @@
+import { collectErrorMetadata } from "./utils.js";
+import { createCustomViteLogger, enhanceViteSSRError, getViteErrorPayload } from "./vite.js";
+export {
+  collectErrorMetadata,
+  createCustomViteLogger,
+  enhanceViteSSRError,
+  getViteErrorPayload
+};

package/dist/core/errors/dev/utils.d.ts

@@ -0,0 +1,10 @@
+import { ErrorWithMetadata } from '../errors.js';
+export declare const incompatiblePackages: {
+    'react-spectrum': string;
+};
+export declare const incompatPackageExp: RegExp;
+/**
+ * Takes any error-like object and returns a standardized Error + metadata object.
+ * Useful for consistent reporting regardless of where the error surfaced from.
+ */
+export declare function collectErrorMetadata(e: any, filePath?: URL): ErrorWithMetadata;

package/dist/core/errors/dev/utils.js

@@ -0,0 +1,69 @@
+import * as fs from "node:fs";
+import { AggregateError } from "../errors.js";
+import { codeFrame } from "../printer.js";
+import { collectInfoFromStacktrace } from "../utils.js";
+const incompatiblePackages = {
+  "react-spectrum": `@adobe/react-spectrum is not compatible with Vite's server-side rendering mode at the moment. You can still use React Spectrum from the client. Create an island React component and use the client:only directive. From there you can use React Spectrum.`
+};
+const incompatPackageExp = new RegExp(`(${Object.keys(incompatiblePackages).join("|")})`);
+function collectErrorMetadata(e, filePath) {
+  const err = AggregateError.is(e) ? e.errors : [e];
+  err.forEach((error) => {
+    if (error.stack) {
+      error = collectInfoFromStacktrace(e);
+    }
+    if (!error.frame && error.loc) {
+      try {
+        const fileContents = fs.readFileSync(error.loc.file, "utf8");
+        const frame = codeFrame(fileContents, error.loc);
+        error.frame = frame;
+      } catch {
+      }
+    }
+    if (!error.hint) {
+      error.hint = generateHint(e, filePath);
+    }
+  });
+  if (!AggregateError.is(e) && Array.isArray(e.errors)) {
+    e.errors.forEach((buildError, i) => {
+      const { location, pluginName } = buildError;
+      if (location) {
+        err[i].loc = { file: location.file, line: location.line, column: location.column };
+        err[i].id = err[0].id || (location == null ? void 0 : location.file);
+      }
+      const possibleFilePath = err[i].pluginCode || err[i].id || (location == null ? void 0 : location.file);
+      if (possibleFilePath && !err[i].frame) {
+        try {
+          const fileContents = fs.readFileSync(possibleFilePath, "utf8");
+          err[i].frame = codeFrame(fileContents, { ...err[i].loc, file: possibleFilePath });
+        } catch {
+        }
+      }
+      if (pluginName) {
+        err[i].plugin = pluginName;
+      }
+      err[i].hint = generateHint(err[0], filePath);
+    });
+  }
+  return err[0];
+}
+function generateHint(err, filePath) {
+  var _a, _b;
+  if (/Unknown file extension \"\.(jsx|vue|svelte|astro|css)\" for /.test(err.message)) {
+    return "You likely need to add this package to `vite.ssr.noExternal` in your astro config file.";
+  } else if (err.toString().startsWith("ReferenceError") && ((_b = ((_a = err.loc) == null ? void 0 : _a.file) ?? (filePath == null ? void 0 : filePath.pathname)) == null ? void 0 : _b.endsWith(".astro"))) {
+    return "export statements in `.astro` files do not have access to local variable declarations, only imported values.";
+  } else {
+    const res = incompatPackageExp.exec(err.stack);
+    if (res) {
+      const key = res[0];
+      return incompatiblePackages[key];
+    }
+  }
+  return void 0;
+}
+export {
+  collectErrorMetadata,
+  incompatPackageExp,
+  incompatiblePackages
+};

package/dist/core/errors/dev/vite.d.ts

@@ -0,0 +1,11 @@
+import { type ErrorPayload, type Logger, type LogLevel, type ViteDevServer } from 'vite';
+import { AstroError, type ErrorWithMetadata } from '../errors.js';
+/**
+ * Custom logger with better error reporting for incompatible packages
+ */
+export declare function createCustomViteLogger(logLevel: LogLevel): Logger;
+export declare function enhanceViteSSRError(error: Error, filePath?: URL, viteServer?: ViteDevServer): AstroError;
+/**
+ * Generate a payload for Vite's error overlay
+ */
+export declare function getViteErrorPayload(err: ErrorWithMetadata): ErrorPayload;

package/dist/core/errors/dev/vite.js

@@ -0,0 +1,88 @@
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import {
+  createLogger
+} from "vite";
+import { AstroErrorCodes } from "../codes.js";
+import { AstroError } from "../errors.js";
+import { incompatPackageExp } from "./utils.js";
+function createCustomViteLogger(logLevel) {
+  const viteLogger = createLogger(logLevel);
+  const logger = {
+    ...viteLogger,
+    error(msg, options) {
+      if (incompatPackageExp.test(msg))
+        return;
+      return viteLogger.error(msg, options);
+    }
+  };
+  return logger;
+}
+function enhanceViteSSRError(error, filePath, viteServer) {
+  var _a, _b;
+  if (viteServer) {
+    try {
+      viteServer.ssrFixStacktrace(error);
+    } catch {
+    }
+  }
+  const newError = new AstroError({
+    name: error.name,
+    message: error.message,
+    location: error.loc,
+    stack: error.stack,
+    errorCode: error.errorCode ? error.errorCode : AstroErrorCodes.UnknownViteSSRError
+  });
+  if (filePath && /failed to load module for ssr:/.test(error.message)) {
+    const importName = (_a = error.message.split("for ssr:").at(1)) == null ? void 0 : _a.trim();
+    if (importName) {
+      newError.setMessage(`Could not import "${importName}"`);
+      newError.setHint("Make sure the file exists");
+      newError.setErrorCode(AstroErrorCodes.FailedToLoadModuleSSR);
+      const path = fileURLToPath(filePath);
+      const content = fs.readFileSync(path).toString();
+      const lns = content.split("\n");
+      const line = lns.findIndex((ln) => ln.includes(importName));
+      if (line !== -1) {
+        const column = (_b = lns[line]) == null ? void 0 : _b.indexOf(importName);
+        newError.setLocation({
+          file: path,
+          line: line + 1,
+          column
+        });
+      }
+    }
+  }
+  return newError;
+}
+function getViteErrorPayload(err) {
+  var _a, _b, _c, _d;
+  let plugin = err.plugin;
+  if (!plugin && err.hint) {
+    plugin = "astro";
+  }
+  const message = `${err.message}
+
+${err.hint ?? ""}`;
+  const frame = (_a = err.frame) == null ? void 0 : _a.replace(/\t/g, " ");
+  return {
+    type: "error",
+    err: {
+      ...err,
+      frame,
+      loc: {
+        file: (_b = err.loc) == null ? void 0 : _b.file,
+        line: ((_c = err.loc) == null ? void 0 : _c.line) ?? 0,
+        column: ((_d = err.loc) == null ? void 0 : _d.column) ?? 0
+      },
+      plugin,
+      message: message.trim(),
+      stack: err.stack
+    }
+  };
+}
+export {
+  createCustomViteLogger,
+  enhanceViteSSRError,
+  getViteErrorPayload
+};

package/dist/core/errors/errors.d.ts

@@ -0,0 +1,80 @@
+import type { DiagnosticCode } from '@astrojs/compiler/shared/diagnostics.js';
+import { AstroErrorCodes } from './codes.js';
+interface ErrorProperties {
+    errorCode: AstroErrorCodes | DiagnosticCode;
+    name?: string;
+    message?: string;
+    location?: ErrorLocation;
+    hint?: string;
+    stack?: string;
+    frame?: string;
+}
+export interface ErrorLocation {
+    file?: string;
+    line?: number;
+    column?: number;
+}
+declare type ErrorTypes = 'CSSError' | 'CompilerError' | 'RuntimeError' | 'MarkdownError' | 'AstroAggregateError';
+export declare class AstroError extends Error {
+    errorCode: AstroErrorCodes | DiagnosticCode;
+    loc: ErrorLocation | undefined;
+    hint: string | undefined;
+    frame: string | undefined;
+    type: ErrorTypes | undefined;
+    constructor(props: ErrorProperties, ...params: any);
+    setErrorCode(errorCode: AstroErrorCodes | DiagnosticCode): void;
+    setLocation(location: ErrorLocation): void;
+    setName(name: string): void;
+    setMessage(message: string): void;
+    setHint(hint: string): void;
+    setFrame(source: string, location: ErrorLocation): void;
+}
+export declare class CSSError extends AstroError {
+    type: ErrorTypes;
+    static is(err: Error | unknown): boolean;
+}
+export declare class CompilerError extends AstroError {
+    type: ErrorTypes;
+    constructor(props: ErrorProperties & {
+        errorCode: DiagnosticCode | AstroErrorCodes.UnknownCompilerError;
+    }, ...params: any);
+    static is(err: Error | unknown): boolean;
+}
+export declare class RuntimeError extends AstroError {
+    type: ErrorTypes;
+    static is(err: Error | unknown): boolean;
+}
+export declare class MarkdownError extends AstroError {
+    type: ErrorTypes;
+    static is(err: Error | unknown): boolean;
+}
+export declare class AggregateError extends AstroError {
+    type: ErrorTypes;
+    errors: AstroError[];
+    constructor(props: ErrorProperties & {
+        errors: AstroError[];
+    }, ...params: any);
+    static is(err: Error | unknown): boolean;
+}
+/**
+ * Generic object representing an error with all possible data
+ * Compatible with both Astro's and Vite's errors
+ */
+export interface ErrorWithMetadata {
+    [name: string]: any;
+    type?: ErrorTypes;
+    message: string;
+    stack: string;
+    code?: number;
+    hint?: string;
+    id?: string;
+    frame?: string;
+    plugin?: string;
+    pluginCode?: string;
+    loc?: {
+        file?: string;
+        line?: number;
+        column?: number;
+    };
+}
+export {};

package/dist/core/errors/errors.js

@@ -0,0 +1,94 @@
+import { AstroErrorCodes } from "./codes.js";
+import { codeFrame } from "./printer.js";
+class AstroError extends Error {
+  constructor(props, ...params) {
+    super(...params);
+    const { errorCode, name, message, stack, location, hint, frame } = props;
+    this.errorCode = errorCode;
+    if (name) {
+      this.name = name;
+    } else {
+      this.name = AstroErrorCodes[errorCode];
+    }
+    if (message)
+      this.message = message;
+    this.stack = stack ? stack : this.stack;
+    this.loc = location;
+    this.hint = hint;
+    this.frame = frame;
+  }
+  setErrorCode(errorCode) {
+    this.errorCode = errorCode;
+    this.name = AstroErrorCodes[errorCode];
+  }
+  setLocation(location) {
+    this.loc = location;
+  }
+  setName(name) {
+    this.name = name;
+  }
+  setMessage(message) {
+    this.message = message;
+  }
+  setHint(hint) {
+    this.hint = hint;
+  }
+  setFrame(source, location) {
+    this.frame = codeFrame(source, location);
+  }
+}
+class CSSError extends AstroError {
+  constructor() {
+    super(...arguments);
+    this.type = "CSSError";
+  }
+  static is(err) {
+    return err.type === "CSSError";
+  }
+}
+class CompilerError extends AstroError {
+  constructor(props, ...params) {
+    super(props, ...params);
+    this.type = "CompilerError";
+    this.name = "CompilerError";
+  }
+  static is(err) {
+    return err.type === "CompilerError";
+  }
+}
+class RuntimeError extends AstroError {
+  constructor() {
+    super(...arguments);
+    this.type = "RuntimeError";
+  }
+  static is(err) {
+    return err.type === "RuntimeError";
+  }
+}
+class MarkdownError extends AstroError {
+  constructor() {
+    super(...arguments);
+    this.type = "MarkdownError";
+  }
+  static is(err) {
+    return err.type === "MarkdownError";
+  }
+}
+class AggregateError extends AstroError {
+  constructor(props, ...params) {
+    super(props, ...params);
+    this.type = "AstroAggregateError";
+    this.errors = props.errors;
+  }
+  static is(err) {
+    return err.type === "AstroAggregateError";
+  }
+}
+export {
+  AggregateError,
+  AstroError,
+  CSSError,
+  CompilerError,
+  MarkdownError,
+  RuntimeError
+};

package/dist/core/errors/index.d.ts

@@ -0,0 +1,5 @@
+export { AstroErrorCodes } from './codes.js';
+export type { ErrorLocation, ErrorWithMetadata } from './errors';
+export { AggregateError, AstroError, CompilerError, CSSError, MarkdownError, RuntimeError, } from './errors.js';
+export { codeFrame } from './printer.js';
+export { collectInfoFromStacktrace, createSafeError, positionAt } from './utils.js';

package/dist/core/errors/index.js

@@ -0,0 +1,24 @@
+import { AstroErrorCodes } from "./codes.js";
+import {
+  AggregateError,
+  AstroError,
+  CompilerError,
+  CSSError,
+  MarkdownError,
+  RuntimeError
+} from "./errors.js";
+import { codeFrame } from "./printer.js";
+import { collectInfoFromStacktrace, createSafeError, positionAt } from "./utils.js";
+export {
+  AggregateError,
+  AstroError,
+  AstroErrorCodes,
+  CSSError,
+  CompilerError,
+  MarkdownError,
+  RuntimeError,
+  codeFrame,
+  collectInfoFromStacktrace,
+  createSafeError,
+  positionAt
+};

package/dist/core/errors/printer.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorLocation } from './errors.js';
+/** Generate a code frame from string and an error location */
+export declare function codeFrame(src: string, loc: ErrorLocation): string;

package/dist/core/errors/printer.js

@@ -0,0 +1,34 @@
+import eol from "eol";
+function codeFrame(src, loc) {
+  if (!loc || loc.line === void 0 || loc.column === void 0) {
+    return "";
+  }
+  const lines = eol.lf(src).split("\n").map((ln) => ln.replace(/\t/g, "  "));
+  const visibleLines = [];
+  for (let n = -2; n <= 2; n++) {
+    if (lines[loc.line + n])
+      visibleLines.push(loc.line + n);
+  }
+  let gutterWidth = 0;
+  for (const lineNo of visibleLines) {
+    let w = `> ${lineNo}`;
+    if (w.length > gutterWidth)
+      gutterWidth = w.length;
+  }
+  let output = "";
+  for (const lineNo of visibleLines) {
+    const isFocusedLine = lineNo === loc.line - 1;
+    output += isFocusedLine ? "> " : "  ";
+    output += `${lineNo + 1} | ${lines[lineNo]}
+`;
+    if (isFocusedLine)
+      output += `${Array.from({ length: gutterWidth }).join(" ")}  | ${Array.from({
+        length: loc.column
+      }).join(" ")}^
+`;
+  }
+  return output;
+}
+export {
+  codeFrame
+};

package/dist/core/errors/utils.d.ts

@@ -0,0 +1,13 @@
+import type { SSRError } from '../../@types/astro.js';
+export declare function collectInfoFromStacktrace(error: SSRError): SSRError;
+/**
+ * Get the line and character based on the offset
+ * @param offset The index of the position
+ * @param text The text for which the position should be retrived
+ */
+export declare function positionAt(offset: number, text: string): {
+    line: number;
+    column: number;
+};
+/** Coalesce any throw variable to an Error instance. */
+export declare function createSafeError(err: any): Error;