astro 1.6.1 → 1.6.3

package/dist/@types/typed-emitter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The MIT License (MIT)
+ * Copyright (c) 2018 Andy Wermke
+ * https://github.com/andywer/typed-emitter/blob/9a139b6fa0ec6b0db6141b5b756b784e4f7ef4e4/LICENSE
+ */
+export declare type EventMap = {
+    [key: string]: (...args: any[]) => void;
+};
+/**
+ * Type-safe event emitter.
+ *
+ * Use it like this:
+ *
+ * ```typescript
+ * type MyEvents = {
+ *   error: (error: Error) => void;
+ *   message: (from: string, content: string) => void;
+ * }
+ *
+ * const myEmitter = new EventEmitter() as TypedEmitter<MyEvents>;
+ *
+ * myEmitter.emit("error", "x")  // <- Will catch this type error;
+ * ```
+ */
+interface TypedEventEmitter<Events extends EventMap> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): boolean;
+    eventNames(): (keyof Events | string | symbol)[];
+    rawListeners<E extends keyof Events>(event: E): Events[E][];
+    listeners<E extends keyof Events>(event: E): Events[E][];
+    listenerCount<E extends keyof Events>(event: E): number;
+    getMaxListeners(): number;
+    setMaxListeners(maxListeners: number): this;
+}
+export default TypedEventEmitter;

package/dist/cli/index.js

@@ -1,6 +1,5 @@
 import * as colors from "kleur/colors";
 import { pathToFileURL } from "url";
-import { normalizePath } from "vite";
 import yargs from "yargs-parser";
 import { z } from "zod";
 import add from "../core/add/index.js";
@@ -9,8 +8,7 @@ import {
   createSettings,
   openConfig,
   resolveConfigPath,
-  resolveFlags,
-  resolveRoot
+  resolveFlags
 } from "../core/config/index.js";
 import { ASTRO_VERSION } from "../core/constants.js";
 import devServer from "../core/dev/index.js";
@@ -19,7 +17,6 @@ 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 * as event from "../events/index.js";
 import { eventConfigError, eventError, telemetry } from "../events/index.js";
@@ -137,53 +134,18 @@ async function runCommand(cmd, flags) {
   let settings = createSettings(initialAstroConfig, root);
   switch (cmd) {
     case "dev": {
-      async function startDevServer({ isRestart = false } = {}) {
-        const { watcher, stop } = await devServer(settings, { logging, telemetry, isRestart });
-        let restartInFlight = false;
-        const configFlag = resolveFlags(flags).config;
-        const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
-        const resolvedRoot = appendForwardSlash(resolveRoot(root));
-        const handleServerRestart = (logMsg) => async function(changedFile) {
-          if (restartInFlight)
-            return;
-          let shouldRestart = false;
-          shouldRestart = configFlag ? !!configFlagPath && normalizePath(configFlagPath) === normalizePath(changedFile) : new RegExp(
-            `${normalizePath(resolvedRoot)}.*astro.config.((mjs)|(cjs)|(js)|(ts))$`
-          ).test(normalizePath(changedFile));
-          if (!shouldRestart && settings.watchFiles.length > 0) {
-            shouldRestart = settings.watchFiles.some(
-              (path) => normalizePath(path) === normalizePath(changedFile)
-            );
-          }
-          if (!shouldRestart)
-            return;
-          restartInFlight = true;
-          console.clear();
-          try {
-            const newConfig = await openConfig({
-              cwd: root,
-              flags,
-              cmd,
-              logging,
-              isRestart: true
-            });
-            info(logging, "astro", logMsg + "\n");
-            let astroConfig = newConfig.astroConfig;
-            settings = createSettings(astroConfig, root);
-            await stop();
-            await startDevServer({ isRestart: true });
-          } catch (e) {
-            await handleConfigError(e, { cwd: root, flags, logging });
-            await stop();
-            info(logging, "astro", "Continuing with previous valid configuration\n");
-            await startDevServer({ isRestart: true });
-          }
-        };
-        watcher.on("change", handleServerRestart("Configuration updated. Restarting..."));
-        watcher.on("unlink", handleServerRestart("Configuration removed. Restarting..."));
-        watcher.on("add", handleServerRestart("Configuration added. Restarting..."));
-      }
-      await startDevServer({ isRestart: false });
+      const configFlag = resolveFlags(flags).config;
+      const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
+      await devServer(settings, {
+        configFlag,
+        configFlagPath,
+        logging,
+        telemetry,
+        handleConfigError(e) {
+          handleConfigError(e, { cwd: root, flags, logging });
+          info(logging, "astro", "Continuing with previous valid configuration\n");
+        }
+      });
       return await new Promise(() => {
       });
     }

package/dist/core/build/generate.js

@@ -11,7 +11,7 @@ import {
 } from "../../core/path.js";
 import { runHookBuildGenerated } from "../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
-import { call as callEndpoint } from "../endpoint/index.js";
+import { call as callEndpoint, throwIfRedirectNotAllowed } from "../endpoint/index.js";
 import { debug, info } from "../logger/core.js";
 import { createEnvironment, createRenderContext, renderPage } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
@@ -254,15 +254,19 @@ async function generatePath(pathname, opts, gopts) {
     const endpointHandler = mod;
     const result = await callEndpoint(endpointHandler, env, ctx);
     if (result.type === "response") {
-      throw new Error(`Returning a Response from an endpoint is not supported in SSG mode.`);
+      throwIfRedirectNotAllowed(result.response, opts.settings.config);
+      if (!result.response.body)
+        return;
+      body = await result.response.text();
+    } else {
+      body = result.body;
+      encoding = result.encoding;
     }
-    body = result.body;
-    encoding = result.encoding;
   } else {
     const response = await renderPage(mod, ctx, env);
-    if (response.status !== 200 || !response.body) {
+    throwIfRedirectNotAllowed(response, opts.settings.config);
+    if (!response.body)
       return;
-    }
     body = await response.text();
   }
   const outFolder = getOutFolder(settings.config, pathname, pageData.route.type);

package/dist/core/compile/compile.d.ts

@@ -1,15 +1,15 @@
 import type { TransformResult } from '@astrojs/compiler';
+import type { ResolvedConfig } from 'vite';
 import type { AstroConfig } from '../../@types/astro';
-import type { TransformStyle } from './types';
 declare type CompileResult = TransformResult & {
     cssDeps: Set<string>;
     source: string;
 };
 export interface CompileProps {
-    config: AstroConfig;
+    astroConfig: AstroConfig;
+    viteConfig: ResolvedConfig;
     filename: string;
     source: string;
-    transformStyle: TransformStyle;
 }
 export declare function isCached(config: AstroConfig, filename: string): boolean;
 export declare function getCachedSource(config: AstroConfig, filename: string): string | null;

package/dist/core/compile/compile.js

@@ -6,25 +6,30 @@ import { resolvePath, viteID } from "../util.js";
 import { createStylePreprocessor } from "./style.js";
 const configCache = /* @__PURE__ */ new WeakMap();
 async function compile({
-  config,
+  astroConfig,
+  viteConfig,
   filename,
-  source,
-  transformStyle
+  source
 }) {
   var _a;
   let cssDeps = /* @__PURE__ */ new Set();
   let cssTransformErrors = [];
   const transformResult = await transform(source, {
     pathname: filename,
-    projectRoot: config.root.toString(),
-    site: (_a = config.site) == null ? void 0 : _a.toString(),
+    projectRoot: astroConfig.root.toString(),
+    site: (_a = astroConfig.site) == null ? void 0 : _a.toString(),
     sourcefile: filename,
     sourcemap: "both",
     internalURL: `/@fs${prependForwardSlash(
       viteID(new URL("../../runtime/server/index.js", import.meta.url))
     )}`,
     experimentalStaticExtraction: true,
-    preprocessStyle: createStylePreprocessor(transformStyle, cssDeps, cssTransformErrors),
+    preprocessStyle: createStylePreprocessor({
+      filename,
+      viteConfig,
+      cssDeps,
+      cssTransformErrors
+    }),
     async resolvePath(specifier) {
       return resolvePath(specifier, filename);
     }
@@ -96,13 +101,13 @@ function invalidateCompilation(config, filename) {
   }
 }
 async function cachedCompilation(props) {
-  const { config, filename } = props;
+  const { astroConfig, filename } = props;
   let cache;
-  if (!configCache.has(config)) {
+  if (!configCache.has(astroConfig)) {
     cache = /* @__PURE__ */ new Map();
-    configCache.set(config, cache);
+    configCache.set(astroConfig, cache);
   } else {
-    cache = configCache.get(config);
+    cache = configCache.get(astroConfig);
   }
   if (cache.has(filename)) {
     return cache.get(filename);

package/dist/core/compile/style.d.ts

@@ -1,5 +1,8 @@
 import type { TransformOptions } from '@astrojs/compiler';
-import type { TransformStyle } from './types';
-declare type PreprocessStyle = TransformOptions['preprocessStyle'];
-export declare function createStylePreprocessor(transformStyle: TransformStyle, cssDeps: Set<string>, errors: Error[]): PreprocessStyle;
-export {};
+import { ResolvedConfig } from 'vite';
+export declare function createStylePreprocessor({ filename, viteConfig, cssDeps, cssTransformErrors, }: {
+    filename: string;
+    viteConfig: ResolvedConfig;
+    cssDeps: Set<string>;
+    cssTransformErrors: Error[];
+}): TransformOptions['preprocessStyle'];

package/dist/core/compile/style.js

@@ -1,13 +1,23 @@
-function createStylePreprocessor(transformStyle, cssDeps, errors) {
-  const preprocessStyle = async (value, attrs) => {
+import fs from "fs";
+import { preprocessCSS } from "vite";
+import { AstroErrorCodes } from "../errors/codes.js";
+import { CSSError } from "../errors/errors.js";
+import { positionAt } from "../errors/index.js";
+function createStylePreprocessor({
+  filename,
+  viteConfig,
+  cssDeps,
+  cssTransformErrors
+}) {
+  return async (content, attrs) => {
+    var _a;
     const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
+    const id = `${filename}?astro&type=style&lang${lang}`;
     try {
-      const result = await transformStyle(value, lang);
-      if (!result)
-        return null;
-      for (const dep of result.deps) {
+      const result = await preprocessCSS(content, id, viteConfig);
+      (_a = result.deps) == null ? void 0 : _a.forEach((dep) => {
         cssDeps.add(dep);
-      }
+      });
       let map;
       if (result.map) {
         if (typeof result.map === "string") {
@@ -18,13 +28,56 @@ function createStylePreprocessor(transformStyle, cssDeps, errors) {
       }
       return { code: result.code, map };
     } catch (err) {
-      errors.push(err);
-      return {
-        error: err + ""
-      };
+      try {
+        err = enhanceCSSError(err, filename);
+      } catch {
+      }
+      cssTransformErrors.push(err);
+      return { error: err + "" };
     }
   };
-  return preprocessStyle;
+}
+function enhanceCSSError(err, filename) {
+  var _a;
+  const fileContent = fs.readFileSync(filename).toString();
+  const styleTagBeginning = fileContent.indexOf(((_a = err.input) == null ? void 0 : _a.source) ?? err.code);
+  if (err.name === "CssSyntaxError") {
+    const errorLine = positionAt(styleTagBeginning, fileContent).line + (err.line ?? 0);
+    return new CSSError({
+      errorCode: AstroErrorCodes.CssSyntaxError,
+      message: err.reason,
+      location: {
+        file: filename,
+        line: errorLine,
+        column: err.column
+      }
+    });
+  }
+  if (err.line && err.column) {
+    const errorLine = positionAt(styleTagBeginning, fileContent).line + (err.line ?? 0);
+    return new CSSError({
+      errorCode: AstroErrorCodes.CssUnknownError,
+      message: err.message,
+      location: {
+        file: filename,
+        line: errorLine,
+        column: err.column
+      },
+      frame: err.frame
+    });
+  }
+  const errorPosition = positionAt(styleTagBeginning, fileContent);
+  errorPosition.line += 1;
+  return new CSSError({
+    errorCode: AstroErrorCodes.CssUnknownError,
+    message: err.message,
+    location: {
+      file: filename,
+      line: errorPosition.line,
+      column: 0
+    },
+    frame: err.frame
+  });
 }
 export {
   createStylePreprocessor

package/dist/core/config/config.d.ts

@@ -1,12 +1,14 @@
+/// <reference types="node" />
 import type { Arguments as Flags } from 'yargs-parser';
 import type { AstroConfig, AstroUserConfig, CLIFlags } from '../../@types/astro';
+import fs from 'fs';
 import { LogOptions } from '../logger/core.js';
 export declare const LEGACY_ASTRO_CONFIG_KEYS: Set<string>;
 /** Turn raw config values into normalized values */
-export declare function validateConfig(userConfig: any, root: string, cmd: string, logging: LogOptions): Promise<AstroConfig>;
+export declare function validateConfig(userConfig: any, root: string, cmd: string): Promise<AstroConfig>;
 /** Convert the generic "yargs" flag object into our own, custom TypeScript object. */
 export declare function resolveFlags(flags: Partial<Flags>): CLIFlags;
-export declare function resolveRoot(cwd?: string): string;
+export declare function resolveRoot(cwd?: string | URL): string;
 interface LoadConfigOptions {
     cwd?: string;
     flags?: Flags;
@@ -15,6 +17,7 @@ interface LoadConfigOptions {
     logging: LogOptions;
     /** Invalidate when reloading a previously loaded config */
     isRestart?: boolean;
+    fsMod?: typeof fs;
 }
 /**
  * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file
@@ -36,6 +39,7 @@ export declare function openConfig(configOptions: LoadConfigOptions): Promise<Op
  */
 export declare function loadConfig(configOptions: LoadConfigOptions): Promise<AstroConfig>;
 /** Attempt to resolve an Astro configuration object. Normalize, validate, and return. */
-export declare function resolveConfig(userConfig: AstroUserConfig, root: string, flags: CLIFlags | undefined, cmd: string, logging: LogOptions): Promise<AstroConfig>;
+export declare function resolveConfig(userConfig: AstroUserConfig, root: string, flags: CLIFlags | undefined, cmd: string): Promise<AstroConfig>;
+export declare function createDefaultDevConfig(userConfig?: AstroUserConfig, root?: string): Promise<AstroConfig>;
 export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;
 export {};

package/dist/core/config/config.js

@@ -20,7 +20,7 @@ const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "buildOptions",
   "devOptions"
 ]);
-async function validateConfig(userConfig, root, cmd, logging) {
+async function validateConfig(userConfig, root, cmd) {
   const fileProtocolRoot = pathToFileURL(root + path.sep);
   if (userConfig.hasOwnProperty("renderers")) {
     console.error('Astro "renderers" are now "integrations"!');
@@ -80,6 +80,9 @@ function resolveFlags(flags) {
   };
 }
 function resolveRoot(cwd) {
+  if (cwd instanceof URL) {
+    cwd = fileURLToPath(cwd);
+  }
   return cwd ? path.resolve(cwd) : process.cwd();
 }
 function mergeCLIFlags(astroConfig, flags, cmd) {
@@ -129,13 +132,7 @@ async function openConfig(configOptions) {
   if (config) {
     userConfig = config.value;
   }
-  const astroConfig = await resolveConfig(
-    userConfig,
-    root,
-    flags,
-    configOptions.cmd,
-    configOptions.logging
-  );
+  const astroConfig = await resolveConfig(userConfig, root, flags, configOptions.cmd);
   return {
     astroConfig,
     userConfig,
@@ -144,6 +141,7 @@ async function openConfig(configOptions) {
   };
 }
 async function tryLoadConfig(configOptions, flags, root) {
+  const fsMod = configOptions.fsMod ?? fs;
   let finallyCleanup = async () => {
   };
   try {
@@ -158,7 +156,8 @@ async function tryLoadConfig(configOptions, flags, root) {
         root,
         `.temp.${Date.now()}.config${path.extname(configPath)}`
       );
-      await fs.promises.writeFile(tempConfigPath, await fs.promises.readFile(configPath));
+      const currentConfigContent = await fsMod.promises.readFile(configPath, "utf-8");
+      await fs.promises.writeFile(tempConfigPath, currentConfigContent);
       finallyCleanup = async () => {
         try {
           await fs.promises.unlink(tempConfigPath);
@@ -213,13 +212,16 @@ async function loadConfig(configOptions) {
   if (config) {
     userConfig = config.value;
   }
-  return resolveConfig(userConfig, root, flags, configOptions.cmd, configOptions.logging);
+  return resolveConfig(userConfig, root, flags, configOptions.cmd);
 }
-async function resolveConfig(userConfig, root, flags = {}, cmd, logging) {
+async function resolveConfig(userConfig, root, flags = {}, cmd) {
   const mergedConfig = mergeCLIFlags(userConfig, flags, cmd);
-  const validatedConfig = await validateConfig(mergedConfig, root, cmd, logging);
+  const validatedConfig = await validateConfig(mergedConfig, root, cmd);
   return validatedConfig;
 }
+function createDefaultDevConfig(userConfig = {}, root = process.cwd()) {
+  return resolveConfig(userConfig, root, void 0, "dev");
+}
 function mergeConfigRecursively(defaults, overrides, rootPath) {
   const merged = { ...defaults };
   for (const key in overrides) {
@@ -257,6 +259,7 @@ function mergeConfig(defaults, overrides, isRoot = true) {
 }
 export {
   LEGACY_ASTRO_CONFIG_KEYS,
+  createDefaultDevConfig,
   loadConfig,
   mergeConfig,
   openConfig,

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

@@ -1,4 +1,4 @@
-export { openConfig, resolveConfigPath, resolveFlags, resolveRoot, validateConfig, } from './config.js';
+export { createDefaultDevConfig, openConfig, resolveConfigPath, resolveFlags, resolveRoot, validateConfig, } from './config.js';
 export type { AstroConfigSchema } from './schema';
-export { createSettings } from './settings.js';
+export { createDefaultDevSettings, createSettings } from './settings.js';
 export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';

package/dist/core/config/index.js

@@ -1,13 +1,16 @@
 import {
+  createDefaultDevConfig,
   openConfig,
   resolveConfigPath,
   resolveFlags,
   resolveRoot,
   validateConfig
 } from "./config.js";
-import { createSettings } from "./settings.js";
+import { createDefaultDevSettings, createSettings } from "./settings.js";
 import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
+  createDefaultDevConfig,
+  createDefaultDevSettings,
   createSettings,
   loadTSConfig,
   openConfig,