astro 1.6.2 → 1.6.3

package/dist/vite-plugin-astro-server/route.js

@@ -0,0 +1,144 @@
+import mime from "mime";
+import { attachToResponse } from "../core/cookies/index.js";
+import { call as callEndpoint } from "../core/endpoint/dev/index.js";
+import { throwIfRedirectNotAllowed } from "../core/endpoint/index.js";
+import { warn } from "../core/logger/core.js";
+import { appendForwardSlash } from "../core/path.js";
+import { preload, renderPage } from "../core/render/dev/index.js";
+import { getParamsAndProps, GetParamsAndPropsError } from "../core/render/index.js";
+import { createRequest } from "../core/request.js";
+import { matchAllRoutes } from "../core/routing/index.js";
+import { resolvePages } from "../core/util.js";
+import { log404 } from "./common.js";
+import { handle404Response, writeSSRResult, writeWebResponse } from "./response.js";
+function getCustom404Route({ config }, manifest) {
+  const relPages = resolvePages(config).href.replace(config.root.href, "");
+  const pattern = new RegExp(`${appendForwardSlash(relPages)}404.(astro|md)`);
+  return manifest.routes.find((r) => r.component.match(pattern));
+}
+async function matchRoute(pathname, env, manifest) {
+  const { logging, settings, routeCache } = env;
+  const matches = matchAllRoutes(pathname, manifest);
+  for await (const maybeRoute of matches) {
+    const filePath = new URL(`./${maybeRoute.component}`, settings.config.root);
+    const preloadedComponent = await preload({ env, filePath });
+    const [, mod] = preloadedComponent;
+    const paramsAndPropsRes = await getParamsAndProps({
+      mod,
+      route: maybeRoute,
+      routeCache,
+      pathname,
+      logging,
+      ssr: settings.config.output === "server"
+    });
+    if (paramsAndPropsRes !== GetParamsAndPropsError.NoMatchingStaticPath) {
+      return {
+        route: maybeRoute,
+        filePath,
+        preloadedComponent,
+        mod
+      };
+    }
+  }
+  if (matches.length) {
+    warn(
+      logging,
+      "getStaticPaths",
+      `Route pattern matched, but no matching static path found. (${pathname})`
+    );
+  }
+  log404(logging, pathname);
+  const custom404 = getCustom404Route(settings, manifest);
+  if (custom404) {
+    const filePath = new URL(`./${custom404.component}`, settings.config.root);
+    const preloadedComponent = await preload({ env, filePath });
+    const [, mod] = preloadedComponent;
+    return {
+      route: custom404,
+      filePath,
+      preloadedComponent,
+      mod
+    };
+  }
+  return void 0;
+}
+async function handleRoute(matchedRoute, url, pathname, body, origin, env, manifest, req, res) {
+  const { logging, settings } = env;
+  if (!matchedRoute) {
+    return handle404Response(origin, req, res);
+  }
+  const { config } = settings;
+  const filePath = matchedRoute.filePath;
+  const { route, preloadedComponent, mod } = matchedRoute;
+  const buildingToSSR = config.output === "server";
+  const request = createRequest({
+    url,
+    headers: buildingToSSR ? req.headers : new Headers(),
+    method: req.method,
+    body,
+    logging,
+    ssr: buildingToSSR,
+    clientAddress: buildingToSSR ? req.socket.remoteAddress : void 0
+  });
+  const paramsAndPropsRes = await getParamsAndProps({
+    mod,
+    route,
+    routeCache: env.routeCache,
+    pathname,
+    logging,
+    ssr: config.output === "server"
+  });
+  const options = {
+    env,
+    filePath,
+    origin,
+    preload: preloadedComponent,
+    pathname,
+    request,
+    route
+  };
+  if (route.type === "endpoint") {
+    const result = await callEndpoint(options);
+    if (result.type === "response") {
+      if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
+        const fourOhFourRoute = await matchRoute("/404", env, manifest);
+        return handleRoute(
+          fourOhFourRoute,
+          new URL("/404", url),
+          "/404",
+          body,
+          origin,
+          env,
+          manifest,
+          req,
+          res
+        );
+      }
+      throwIfRedirectNotAllowed(result.response, config);
+      await writeWebResponse(res, result.response);
+    } else {
+      let contentType = "text/plain";
+      const filepath = route.pathname || route.segments.map((segment) => segment.map((p) => p.content).join("")).join("/");
+      const computedMimeType = mime.getType(filepath);
+      if (computedMimeType) {
+        contentType = computedMimeType;
+      }
+      const response = new Response(result.body, {
+        status: 200,
+        headers: {
+          "Content-Type": `${contentType};charset=utf-8`
+        }
+      });
+      attachToResponse(response, result.cookies);
+      await writeWebResponse(res, response);
+    }
+  } else {
+    const result = await renderPage(options);
+    throwIfRedirectNotAllowed(result, config);
+    return await writeSSRResult(result, res);
+  }
+}
+export {
+  handleRoute,
+  matchRoute
+};

package/dist/vite-plugin-astro-server/server-state.d.ts

@@ -0,0 +1,15 @@
+export declare type ErrorState = 'fresh' | 'error';
+export interface RouteState {
+    state: ErrorState;
+    error?: Error;
+}
+export interface ServerState {
+    routes: Map<string, RouteState>;
+    state: ErrorState;
+    error?: Error;
+}
+export declare function createServerState(): ServerState;
+export declare function hasAnyFailureState(serverState: ServerState): boolean;
+export declare function setRouteError(serverState: ServerState, pathname: string, error: Error): void;
+export declare function setServerError(serverState: ServerState, error: Error): void;
+export declare function clearRouteError(serverState: ServerState, pathname: string): void;

package/dist/vite-plugin-astro-server/server-state.js

@@ -0,0 +1,42 @@
+function createServerState() {
+  return {
+    routes: /* @__PURE__ */ new Map(),
+    state: "fresh"
+  };
+}
+function hasAnyFailureState(serverState) {
+  return serverState.state !== "fresh";
+}
+function setRouteError(serverState, pathname, error) {
+  if (serverState.routes.has(pathname)) {
+    const routeState = serverState.routes.get(pathname);
+    routeState.state = "error";
+    routeState.error = error;
+  } else {
+    const routeState = {
+      state: "error",
+      error
+    };
+    serverState.routes.set(pathname, routeState);
+  }
+  serverState.state = "error";
+  serverState.error = error;
+}
+function setServerError(serverState, error) {
+  serverState.state = "error";
+  serverState.error = error;
+}
+function clearRouteError(serverState, pathname) {
+  if (serverState.routes.has(pathname)) {
+    serverState.routes.delete(pathname);
+  }
+  serverState.state = "fresh";
+  serverState.error = void 0;
+}
+export {
+  clearRouteError,
+  createServerState,
+  hasAnyFailureState,
+  setRouteError,
+  setServerError
+};

package/dist/vite-plugin-jsx/index.js

@@ -4,7 +4,7 @@ import esbuild from "esbuild";
 import * as colors from "kleur/colors";
 import path from "path";
 import { error } from "../core/logger/core.js";
-import { isMarkdownFile, parseNpmName } from "../core/util.js";
+import { parseNpmName } from "../core/util.js";
 import tagExportsPlugin from "./tag.js";
 const JSX_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx", ".mdx"]);
 const IMPORT_STATEMENTS = {
@@ -131,7 +131,7 @@ function jsx({ settings, logging }) {
         return null;
       }
       const { mode } = viteConfig;
-      if (id.includes(".mdx") || isMarkdownFile(id, { criteria: "includes" })) {
+      if (id.endsWith(".mdx")) {
         const { code: jsxCode2 } = await esbuild.transform(code, {
           loader: getEsbuildLoader(path.extname(id)),
           jsx: "preserve",

package/dist/vite-plugin-load-fallback/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import nodeFs from 'fs';
+import type * as vite from 'vite';
+declare type NodeFileSystemModule = typeof nodeFs;
+export interface LoadFallbackPluginParams {
+    fs?: NodeFileSystemModule;
+}
+export default function loadFallbackPlugin({ fs }: LoadFallbackPluginParams): vite.Plugin | false;
+export {};

package/dist/vite-plugin-load-fallback/index.js

@@ -0,0 +1,26 @@
+import nodeFs from "fs";
+function loadFallbackPlugin({ fs }) {
+  if (!fs || fs === nodeFs) {
+    return false;
+  }
+  return {
+    name: "astro:load-fallback",
+    enforce: "post",
+    async load(id) {
+      try {
+        return await fs.promises.readFile(cleanUrl(id), "utf-8");
+      } catch (e) {
+        try {
+          return await fs.promises.readFile(id, "utf-8");
+        } catch (e2) {
+        }
+      }
+    }
+  };
+}
+const queryRE = /\?.*$/s;
+const hashRE = /#.*$/s;
+const cleanUrl = (url) => url.replace(hashRE, "").replace(queryRE, "");
+export {
+  loadFallbackPlugin as default
+};

package/dist/vite-plugin-markdown/index.js

@@ -39,7 +39,7 @@ function markdown({ settings, logging }) {
     enforce: "pre",
     name: "astro:markdown",
     async load(id) {
-      if (isMarkdownFile(id, { criteria: "endsWith" })) {
+      if (isMarkdownFile(id)) {
         const { fileId, fileUrl } = getFileInfo(id, settings.config);
         const rawFile = await fs.promises.readFile(fileId, "utf-8");
         const raw = safeMatter(rawFile, id);

package/dist/vite-plugin-markdown-legacy/index.js

@@ -9,10 +9,6 @@ import { cachedCompilation } from "../core/compile/index.js";
 import { AstroErrorCodes, MarkdownError } from "../core/errors/index.js";
 import { isMarkdownFile } from "../core/util.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
-import {
-  createTransformStyles,
-  createViteStyleTransformer
-} from "../vite-style-transform/index.js";
 const MARKDOWN_IMPORT_FLAG = "?mdImport";
 const MARKDOWN_CONTENT_FLAG = "?content";
 function safeMatter(source, id) {
@@ -62,23 +58,16 @@ function markdown({ settings }) {
     }
     return false;
   }
-  let styleTransformer;
-  let viteDevServer;
+  let resolvedConfig;
   return {
     name: "astro:markdown",
     enforce: "pre",
-    configResolved(_resolvedConfig) {
-      styleTransformer = createViteStyleTransformer(_resolvedConfig);
-    },
-    configureServer(server) {
-      styleTransformer.viteDevServer = server;
-    },
     async resolveId(id, importer, options) {
-      if (isMarkdownFile(id, { criteria: "endsWith", suffix: MARKDOWN_CONTENT_FLAG })) {
+      if (isMarkdownFile(id, { suffix: MARKDOWN_CONTENT_FLAG })) {
         const resolvedId = await this.resolve(id, importer, { skipSelf: true, ...options });
         return resolvedId == null ? void 0 : resolvedId.id.replace(MARKDOWN_CONTENT_FLAG, "");
       }
-      if (isMarkdownFile(id, { criteria: "endsWith" }) && !isRootImport(importer)) {
+      if (isMarkdownFile(id) && !isRootImport(importer)) {
         const resolvedId = await this.resolve(id, importer, { skipSelf: true, ...options });
         if (resolvedId) {
           return resolvedId.id + MARKDOWN_IMPORT_FLAG;
@@ -87,7 +76,7 @@ function markdown({ settings }) {
       return void 0;
     },
     async load(id, opts) {
-      if (isMarkdownFile(id, { criteria: "endsWith", suffix: MARKDOWN_IMPORT_FLAG })) {
+      if (isMarkdownFile(id, { suffix: MARKDOWN_IMPORT_FLAG })) {
         const { fileId, fileUrl } = getFileInfo(id, config);
         const source = await fs.promises.readFile(fileId, "utf8");
         const { data: frontmatter, content: rawContent } = safeMatter(source, fileId);
@@ -122,7 +111,7 @@ function markdown({ settings }) {
           map: null
         };
       }
-      if (isMarkdownFile(id, { criteria: "endsWith" })) {
+      if (isMarkdownFile(id)) {
         const filename = normalizeFilename(id);
         const source = await fs.promises.readFile(filename, "utf8");
         const renderOpts = config.markdown;
@@ -176,15 +165,10 @@ ${astroResult}
 <head></head>${astroResult}`;
         }
         const compileProps = {
-          config,
+          astroConfig: config,
+          viteConfig: resolvedConfig,
           filename,
-          source: astroResult,
-          transformStyle: createTransformStyles(
-            styleTransformer,
-            filename,
-            Boolean(opts == null ? void 0 : opts.ssr),
-            this
-          )
+          source: astroResult
         };
         let transformResult = await cachedCompilation(compileProps);
         let { code: tsResult } = transformResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -176,8 +176,10 @@
     "astro-scripts": "0.0.9",
     "chai": "^4.3.6",
     "cheerio": "^1.0.0-rc.11",
+    "memfs": "^3.4.7",
     "mocha": "^9.2.2",
     "node-fetch": "^3.2.5",
+    "node-mocks-http": "^1.11.0",
     "rehype-autolink-headings": "^6.1.1",
     "rehype-slug": "^5.0.1",
     "rehype-toc": "^3.0.2",
@@ -197,7 +199,7 @@
     "dev": "astro-scripts dev --prebuild \"src/runtime/server/astro-island.ts\" --prebuild \"src/runtime/client/{idle,load,media,only,visible}.ts\" \"src/**/*.ts\"",
     "postbuild": "astro-scripts copy \"src/**/*.astro\"",
     "benchmark": "node test/benchmark/dev.bench.js && node test/benchmark/build.bench.js",
-    "test:unit": "mocha --exit --timeout 2000 ./test/units/**/*.test.js",
+    "test:unit": "mocha --exit --timeout 30000 ./test/units/**/*.test.js",
     "test": "pnpm run test:unit && mocha --exit --timeout 20000 --ignore **/lit-element.test.js && mocha --timeout 20000 **/lit-element.test.js",
     "test:match": "mocha --timeout 20000 -g",
     "test:e2e": "playwright test",

package/types.d.ts

@@ -6,7 +6,7 @@ export type HTMLTag = keyof astroHTML.JSX.DefinedIntrinsicElements;
 /** The built-in attributes for any known HTML or SVG element name */
 export type HTMLAttributes<Tag extends HTMLTag> = Omit<
 	astroHTML.JSX.IntrinsicElements[Tag],
-	keyof AstroBuiltinAttributes
+	keyof Omit<AstroBuiltinAttributes, 'class:list'>
 >;
 
 // TODO: Enable generic/polymorphic types once compiler output stabilizes in the Language Server

package/dist/vite-style-transform/index.d.ts

@@ -1,2 +0,0 @@
-export type { ViteStyleTransformer } from './style-transform';
-export { createTransformStyles, createViteStyleTransformer } from './style-transform.js';

package/dist/vite-style-transform/index.js

@@ -1,5 +0,0 @@
-import { createTransformStyles, createViteStyleTransformer } from "./style-transform.js";
-export {
-  createTransformStyles,
-  createViteStyleTransformer
-};

package/dist/vite-style-transform/style-transform.d.ts

@@ -1,10 +0,0 @@
-import type { PluginContext } from 'rollup';
-import type { TransformStyle } from '../core/compile/index';
-import { TransformStyleWithVite } from './transform-with-vite.js';
-import type * as vite from 'vite';
-export declare type ViteStyleTransformer = {
-    viteDevServer?: vite.ViteDevServer;
-    transformStyleWithVite: TransformStyleWithVite;
-};
-export declare function createViteStyleTransformer(viteConfig: vite.ResolvedConfig): ViteStyleTransformer;
-export declare function createTransformStyles(viteStyleTransformer: ViteStyleTransformer, filename: string, ssr: boolean, pluginContext?: PluginContext): TransformStyle;

package/dist/vite-style-transform/style-transform.js

@@ -1,80 +0,0 @@
-import { fileURLToPath } from "url";
-import { createTransformStyleWithViteFn } from "./transform-with-vite.js";
-import { readFileSync } from "fs";
-import { AstroErrorCodes } from "../core/errors/codes.js";
-import { CSSError } from "../core/errors/errors.js";
-import { positionAt } from "../core/errors/index.js";
-function createViteStyleTransformer(viteConfig) {
-  return {
-    transformStyleWithVite: createTransformStyleWithViteFn(viteConfig)
-  };
-}
-function getNormalizedIDForPostCSS(filename) {
-  try {
-    const filenameURL = new URL(`file://${filename}`);
-    return fileURLToPath(filenameURL);
-  } catch (err) {
-    return filename;
-  }
-}
-function createTransformStyles(viteStyleTransformer, filename, ssr, pluginContext) {
-  const normalizedID = getNormalizedIDForPostCSS(filename);
-  return async function(styleSource, lang) {
-    var _a;
-    let result;
-    try {
-      result = await viteStyleTransformer.transformStyleWithVite.call(pluginContext, {
-        id: normalizedID,
-        source: styleSource,
-        lang,
-        ssr,
-        viteDevServer: viteStyleTransformer.viteDevServer
-      });
-    } catch (err) {
-      const fileContent = 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);
-        throw 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);
-        throw 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;
-      throw new CSSError({
-        errorCode: AstroErrorCodes.CssUnknownError,
-        message: err.message,
-        location: {
-          file: filename,
-          line: errorPosition.line,
-          column: 0
-        },
-        frame: err.frame
-      });
-    }
-    return result;
-  };
-}
-export {
-  createTransformStyles,
-  createViteStyleTransformer
-};

package/dist/vite-style-transform/transform-with-vite.d.ts

@@ -1,18 +0,0 @@
-import type * as vite from 'vite';
-export declare type TransformHook = (code: string, id: string, ssr?: boolean) => Promise<vite.TransformResult>;
-interface TransformStyleWithViteOptions {
-    id: string;
-    source: string;
-    lang: string;
-    ssr?: boolean;
-    viteDevServer?: vite.ViteDevServer;
-}
-export interface TransformStyleWithVite {
-    (options: TransformStyleWithViteOptions): Promise<{
-        code: string;
-        map: vite.TransformResult['map'];
-        deps: Set<string>;
-    } | null>;
-}
-export declare function createTransformStyleWithViteFn(viteConfig: vite.ResolvedConfig): TransformStyleWithVite;
-export {};

package/dist/vite-style-transform/transform-with-vite.js

@@ -1,33 +0,0 @@
-import { STYLE_EXTENSIONS } from "../core/render/util.js";
-function createTransformStyleWithViteFn(viteConfig) {
-  const viteCSSPlugin = viteConfig.plugins.find(({ name }) => name === "vite:css");
-  if (!viteCSSPlugin)
-    throw new Error(`vite:css plugin couldn't be found`);
-  if (!viteCSSPlugin.transform)
-    throw new Error(`vite:css has no transform() hook`);
-  const transformCss = viteCSSPlugin.transform;
-  return async function({ id, source, lang, ssr, viteDevServer }) {
-    if (!STYLE_EXTENSIONS.has(lang)) {
-      return null;
-    }
-    const styleId = `${id}?astro&type=style&lang${lang}`;
-    viteDevServer == null ? void 0 : viteDevServer.moduleGraph.ensureEntryFromUrl(styleId, ssr, false);
-    const ctx = this ?? { addWatchFile: () => {
-    } };
-    const transformResult = await transformCss.call(ctx, source, styleId, ssr);
-    const { code, map } = transformResult;
-    const deps = /* @__PURE__ */ new Set();
-    const mod = viteDevServer == null ? void 0 : viteDevServer.moduleGraph.getModuleById(styleId);
-    if (mod) {
-      for (const imported of mod.importedModules) {
-        if (imported.file) {
-          deps.add(imported.file);
-        }
-      }
-    }
-    return { code, map, deps };
-  };
-}
-export {
-  createTransformStyleWithViteFn
-};