astro 1.6.2 → 1.6.3

package/dist/core/render/dev/resolve.js

@@ -1,7 +1,7 @@
 import { resolveIdToUrl } from "../../util.js";
-function createResolve(viteServer) {
+function createResolve(loader) {
   return async function(s) {
-    const url = await resolveIdToUrl(viteServer, s);
+    const url = await resolveIdToUrl(loader, s);
     if (url.startsWith("/@fs") && url.endsWith(".jsx")) {
       return url.slice(0, -4);
     } else {

package/dist/core/render/dev/scripts.d.ts

@@ -1,3 +1,3 @@
-import vite from 'vite';
 import type { SSRElement } from '../../../@types/astro';
-export declare function getScriptsForURL(filePath: URL, viteServer: vite.ViteDevServer): Promise<Set<SSRElement>>;
+import type { ModuleLoader } from '../../module-loader/index';
+export declare function getScriptsForURL(filePath: URL, loader: ModuleLoader): Promise<Set<SSRElement>>;

package/dist/core/render/dev/scripts.js

@@ -1,15 +1,15 @@
 import { viteID } from "../../util.js";
 import { createModuleScriptElementWithSrc } from "../ssr-element.js";
 import { crawlGraph } from "./vite.js";
-async function getScriptsForURL(filePath, viteServer) {
+async function getScriptsForURL(filePath, loader) {
   const elements = /* @__PURE__ */ new Set();
   const rootID = viteID(filePath);
-  const modInfo = viteServer.pluginContainer.getModuleInfo(rootID);
+  const modInfo = loader.getModuleInfo(rootID);
   addHoistedScripts(elements, modInfo);
-  for await (const moduleNode of crawlGraph(viteServer, rootID, true)) {
+  for await (const moduleNode of crawlGraph(loader, rootID, true)) {
     const id = moduleNode.id;
     if (id) {
-      const info = viteServer.pluginContainer.getModuleInfo(id);
+      const info = loader.getModuleInfo(id);
       addHoistedScripts(elements, info);
     }
   }

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

@@ -1,3 +1,3 @@
-import vite from 'vite';
+import type { ModuleLoader, ModuleNode } from '../../module-loader/index';
 /** recursively crawl the module graph to get all style files imported by parent id */
-export declare function crawlGraph(viteServer: vite.ViteDevServer, _id: string, isRootFile: boolean, scanned?: Set<string>): AsyncGenerator<vite.ModuleNode, void, unknown>;
+export declare function crawlGraph(loader: ModuleLoader, _id: string, isRootFile: boolean, scanned?: Set<string>): AsyncGenerator<ModuleNode, void, unknown>;

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

@@ -4,10 +4,10 @@ import { unwrapId } from "../../util.js";
 import { STYLE_EXTENSIONS } from "../util.js";
 const fileExtensionsToSSR = /* @__PURE__ */ new Set([".astro", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS]);
 const STRIP_QUERY_PARAMS_REGEX = /\?.*$/;
-async function* crawlGraph(viteServer, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
+async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
   const id = unwrapId(_id);
   const importedModules = /* @__PURE__ */ new Set();
-  const moduleEntriesForId = isRootFile ? viteServer.moduleGraph.getModulesByFile(id) ?? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([viteServer.moduleGraph.getModuleById(id)]);
+  const moduleEntriesForId = isRootFile ? loader.getModulesByFile(id) ?? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([loader.getModuleById(id)]);
   for (const entry of moduleEntriesForId) {
     if (!entry) {
       continue;
@@ -22,10 +22,10 @@ async function* crawlGraph(viteServer, _id, isRootFile, scanned = /* @__PURE__ *
             continue;
           }
           if (fileExtensionsToSSR.has(npath.extname(importedModulePathname))) {
-            const mod = viteServer.moduleGraph.getModuleById(importedModule.id);
+            const mod = loader.getModuleById(importedModule.id);
             if (!(mod == null ? void 0 : mod.ssrModule)) {
               try {
-                await viteServer.ssrLoadModule(importedModule.id);
+                await loader.import(importedModule.id);
               } catch {
               }
             }
@@ -40,7 +40,7 @@ async function* crawlGraph(viteServer, _id, isRootFile, scanned = /* @__PURE__ *
       continue;
     }
     yield importedModule;
-    yield* crawlGraph(viteServer, importedModule.id, false, scanned);
+    yield* crawlGraph(loader, importedModule.id, false, scanned);
   }
 }
 export {

package/dist/core/routing/manifest/create.d.ts

@@ -1,7 +1,14 @@
+/// <reference types="node" />
 import type { AstroSettings, ManifestData } from '../../../@types/astro';
 import type { LogOptions } from '../../logger/core';
-/** Create manifest of all static routes */
-export declare function createRouteManifest({ settings, cwd }: {
+import nodeFs from 'fs';
+export interface CreateRouteManifestParams {
+    /** Astro Settings object */
     settings: AstroSettings;
+    /** Current working directory */
     cwd?: string;
-}, logging: LogOptions): ManifestData;
+    /** fs module, for testing */
+    fsMod?: typeof nodeFs;
+}
+/** Create manifest of all static routes */
+export declare function createRouteManifest({ settings, cwd, fsMod }: CreateRouteManifestParams, logging: LogOptions): ManifestData;

package/dist/core/routing/manifest/create.js

@@ -1,4 +1,4 @@
-import fs from "fs";
+import nodeFs from "fs";
 import { createRequire } from "module";
 import path from "path";
 import slash from "slash";
@@ -132,7 +132,7 @@ function injectedRouteToItem({ config, cwd }, { pattern, entryPoint }) {
     routeSuffix: pattern.slice(pattern.indexOf("."), -ext.length)
   };
 }
-function createRouteManifest({ settings, cwd }, logging) {
+function createRouteManifest({ settings, cwd, fsMod }, logging) {
   var _a;
   const components = [];
   const routes = [];
@@ -142,7 +142,8 @@ function createRouteManifest({ settings, cwd }, logging) {
     ...settings.pageExtensions
   ]);
   const validEndpointExtensions = /* @__PURE__ */ new Set([".js", ".ts"]);
-  function walk(dir, parentSegments, parentParams) {
+  const localFs = fsMod ?? nodeFs;
+  function walk(fs, dir, parentSegments, parentParams) {
     let items = [];
     fs.readdirSync(dir).forEach((basename) => {
       const resolved = path.join(dir, basename);
@@ -208,7 +209,7 @@ function createRouteManifest({ settings, cwd }, logging) {
       const params = parentParams.slice();
       params.push(...item.parts.filter((p) => p.dynamic).map((p) => p.content));
       if (item.isDir) {
-        walk(path.join(dir, item.basename), segments, params);
+        walk(fsMod ?? fs, path.join(dir, item.basename), segments, params);
       } else {
         components.push(item.file);
         const component = item.file;
@@ -232,8 +233,8 @@ function createRouteManifest({ settings, cwd }, logging) {
   }
   const { config } = settings;
   const pages = resolvePages(config);
-  if (fs.existsSync(pages)) {
-    walk(fileURLToPath(pages), [], []);
+  if (localFs.existsSync(pages)) {
+    walk(localFs, fileURLToPath(pages), [], []);
   } else if (settings.injectedRoutes.length === 0) {
     const pagesDirRootRelative = pages.href.slice(settings.config.root.href.length);
     warn(logging, "astro", `Missing pages directory: ${pagesDirRootRelative}`);

package/dist/core/util.d.ts

@@ -1,12 +1,11 @@
-import { ViteDevServer } from 'vite';
 import type { AstroConfig, AstroSettings, RouteType } from '../@types/astro';
+import type { ModuleLoader } from './module-loader';
 /** Returns true if argument is an object of any prototype/class (but not null). */
 export declare function isObject(value: unknown): value is Record<string, any>;
 /** Cross-realm compatible URL */
 export declare function isURL(value: unknown): value is URL;
 /** Check if a file is a markdown file based on its extension */
-export declare function isMarkdownFile(fileId: string, option: {
-    criteria: 'endsWith' | 'includes';
+export declare function isMarkdownFile(fileId: string, option?: {
     suffix?: string;
 }): boolean;
 /** Wraps an object in an array. If an array is passed, ignore it. */
@@ -44,7 +43,7 @@ export declare function getLocalAddress(serverAddress: string, host: string | bo
  * Simulate Vite's resolve and import analysis so we can import the id as an URL
  * through a script tag or a dynamic import as-is.
  */
-export declare function resolveIdToUrl(viteServer: ViteDevServer, id: string): Promise<string>;
+export declare function resolveIdToUrl(loader: ModuleLoader, id: string): Promise<string>;
 export declare function resolveJsToTs(filePath: string): string;
 /**
  * Resolve the hydration paths so that it can be imported in the client

package/dist/core/util.js

@@ -13,16 +13,9 @@ function isURL(value) {
   return Object.prototype.toString.call(value) === "[object URL]";
 }
 function isMarkdownFile(fileId, option) {
-  const _suffix = option.suffix ?? "";
-  if (option.criteria === "endsWith") {
-    for (let markdownFileExtension of SUPPORTED_MARKDOWN_FILE_EXTENSIONS) {
-      if (fileId.endsWith(`${markdownFileExtension}${_suffix}`))
-        return true;
-    }
-    return false;
-  }
+  const _suffix = (option == null ? void 0 : option.suffix) ?? "";
   for (let markdownFileExtension of SUPPORTED_MARKDOWN_FILE_EXTENSIONS) {
-    if (fileId.includes(`${markdownFileExtension}${_suffix}`))
+    if (fileId.endsWith(`${markdownFileExtension}${_suffix}`))
       return true;
   }
   return false;
@@ -131,18 +124,18 @@ function getLocalAddress(serverAddress, host) {
     return serverAddress;
   }
 }
-async function resolveIdToUrl(viteServer, id) {
-  let result = await viteServer.pluginContainer.resolveId(id, void 0);
-  if (!result && id.endsWith(".jsx")) {
-    result = await viteServer.pluginContainer.resolveId(id.slice(0, -4), void 0);
+async function resolveIdToUrl(loader, id) {
+  let resultId = await loader.resolveId(id, void 0);
+  if (!resultId && id.endsWith(".jsx")) {
+    resultId = await loader.resolveId(id.slice(0, -4), void 0);
   }
-  if (!result) {
+  if (!resultId) {
     return VALID_ID_PREFIX + id;
   }
-  if (path.isAbsolute(result.id)) {
-    return "/@fs" + prependForwardSlash(result.id);
+  if (path.isAbsolute(resultId)) {
+    return "/@fs" + prependForwardSlash(resultId);
   }
-  return VALID_ID_PREFIX + result.id;
+  return VALID_ID_PREFIX + resultId;
 }
 function resolveJsToTs(filePath) {
   if (filePath.endsWith(".jsx") && !fs.existsSync(filePath)) {

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

@@ -6,10 +6,6 @@ import { cachedCompilation, getCachedSource } from "../core/compile/index.js";
 import { isRelativePath, prependForwardSlash, startsWithForwardSlash } from "../core/path.js";
 import { viteID } from "../core/util.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
-import {
-  createTransformStyles,
-  createViteStyleTransformer
-} from "../vite-style-transform/index.js";
 import { handleHotUpdate } from "./hmr.js";
 import { parseAstroRequest } from "./query.js";
 const FRONTMATTER_PARSE_REGEXP = /^\-\-\-(.*)^\-\-\-/ms;
@@ -29,8 +25,6 @@ function astro({ settings, logging }) {
     return slash(fileURLToPath(url)) + url.search;
   }
   let resolvedConfig;
-  let styleTransformer;
-  let viteDevServer;
   const srcRootWeb = config.srcDir.pathname.slice(config.root.pathname.length - 1);
   const isBrowserPath = (path) => path.startsWith(srcRootWeb);
   const isFullFilePath = (path) => path.startsWith(prependForwardSlash(slash(fileURLToPath(config.root))));
@@ -48,11 +42,6 @@ function astro({ settings, logging }) {
     enforce: "pre",
     configResolved(_resolvedConfig) {
       resolvedConfig = _resolvedConfig;
-      styleTransformer = createViteStyleTransformer(_resolvedConfig);
-    },
-    configureServer(server) {
-      viteDevServer = server;
-      styleTransformer.viteDevServer = server;
     },
     async resolveId(id, from, opts) {
       if (from) {
@@ -92,10 +81,10 @@ function astro({ settings, logging }) {
         return null;
       }
       const compileProps = {
-        config,
+        astroConfig: config,
+        viteConfig: resolvedConfig,
         filename,
-        source,
-        transformStyle: createTransformStyles(styleTransformer, filename, Boolean(opts == null ? void 0 : opts.ssr), this)
+        source
       };
       switch (query.type) {
         case "style": {
@@ -180,10 +169,10 @@ File: ${filename}`
       }
       const filename = normalizeFilename(parsedId.filename);
       const compileProps = {
-        config,
+        astroConfig: config,
+        viteConfig: resolvedConfig,
         filename,
-        source,
-        transformStyle: createTransformStyles(styleTransformer, filename, Boolean(opts == null ? void 0 : opts.ssr), this)
+        source
       };
       try {
         const transformResult = await cachedCompilation(compileProps);
@@ -278,10 +267,10 @@ ${source}
       if (context.server.config.isProduction)
         return;
       const compileProps = {
-        config,
+        astroConfig: config,
+        viteConfig: resolvedConfig,
         filename: context.file,
-        source: await context.read(),
-        transformStyle: createTransformStyles(styleTransformer, context.file, true)
+        source: await context.read()
       };
       const compile = () => cachedCompilation(compileProps);
       return handleHotUpdate(context, {

package/dist/vite-plugin-astro-postprocess/index.js

@@ -6,7 +6,7 @@ function astro(_opts) {
   return {
     name: "astro:postprocess",
     async transform(code, id) {
-      if (!id.endsWith(".astro") && !isMarkdownFile(id, { criteria: "endsWith" })) {
+      if (!id.endsWith(".astro") && !isMarkdownFile(id)) {
         return null;
       }
       if (!ASTRO_GLOB_REGEX.test(code)) {

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

@@ -0,0 +1,4 @@
+import type * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro';
+import { LogOptions } from '../core/logger/core.js';
+export declare function baseMiddleware(settings: AstroSettings, logging: LogOptions): vite.Connect.NextHandleFunction;

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

@@ -0,0 +1,36 @@
+import notFoundTemplate, { subpathNotUsedTemplate } from "../template/4xx.js";
+import { log404 } from "./common.js";
+import { writeHtmlResponse } from "./response.js";
+function baseMiddleware(settings, logging) {
+  const { config } = settings;
+  const site = config.site ? new URL(config.base, config.site) : void 0;
+  const devRoot = site ? site.pathname : "/";
+  return function devBaseMiddleware(req, res, next) {
+    var _a;
+    const url = req.url;
+    const pathname = decodeURI(new URL(url, "http://vitejs.dev").pathname);
+    if (pathname.startsWith(devRoot)) {
+      req.url = url.replace(devRoot, "/");
+      return next();
+    }
+    if (pathname === "/" || pathname === "/index.html") {
+      log404(logging, pathname);
+      const html = subpathNotUsedTemplate(devRoot, pathname);
+      return writeHtmlResponse(res, 404, html);
+    }
+    if ((_a = req.headers.accept) == null ? void 0 : _a.includes("text/html")) {
+      log404(logging, pathname);
+      const html = notFoundTemplate({
+        statusCode: 404,
+        title: "Not found",
+        tabTitle: "404: Not Found",
+        pathname
+      });
+      return writeHtmlResponse(res, 404, html);
+    }
+    next();
+  };
+}
+export {
+  baseMiddleware
+};

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

@@ -0,0 +1,2 @@
+import { LogOptions } from '../core/logger/core.js';
+export declare function log404(logging: LogOptions, pathname: string): void;

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

@@ -0,0 +1,8 @@
+import { info } from "../core/logger/core.js";
+import * as msg from "../core/messages.js";
+function log404(logging, pathname) {
+  info(logging, "serve", msg.req({ url: pathname, statusCode: 404 }));
+}
+export {
+  log404
+};

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

@@ -0,0 +1,26 @@
+import type { LoaderEvents, ModuleLoader } from '../core/module-loader/index';
+import type { ServerState } from './server-state';
+declare type ReloadFn = () => void;
+export interface DevServerController {
+    state: ServerState;
+    onFileChange: LoaderEvents['file-change'];
+    onHMRError: LoaderEvents['hmr-error'];
+}
+export declare type CreateControllerParams = {
+    loader: ModuleLoader;
+} | {
+    reload: ReloadFn;
+};
+export declare function createController(params: CreateControllerParams): DevServerController;
+export declare function createBaseController({ reload }: {
+    reload: ReloadFn;
+}): DevServerController;
+export declare function createLoaderController(loader: ModuleLoader): DevServerController;
+export interface RunWithErrorHandlingParams {
+    controller: DevServerController;
+    pathname: string;
+    run: () => Promise<any>;
+    onError: (error: unknown) => Error;
+}
+export declare function runWithErrorHandling({ controller: { state }, pathname, run, onError, }: RunWithErrorHandlingParams): Promise<void>;
+export {};

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

@@ -0,0 +1,77 @@
+import {
+  clearRouteError,
+  createServerState,
+  setRouteError,
+  setServerError
+} from "./server-state.js";
+function createController(params) {
+  if ("loader" in params) {
+    return createLoaderController(params.loader);
+  } else {
+    return createBaseController(params);
+  }
+}
+function createBaseController({ reload }) {
+  const serverState = createServerState();
+  const onFileChange = () => {
+    if (serverState.state === "error") {
+      reload();
+    }
+  };
+  const onHMRError = (payload) => {
+    var _a, _b;
+    let msg = ((_a = payload == null ? void 0 : payload.err) == null ? void 0 : _a.message) ?? "Unknown error";
+    let stack = ((_b = payload == null ? void 0 : payload.err) == null ? void 0 : _b.stack) ?? "Unknown stack";
+    let error = new Error(msg);
+    Object.defineProperty(error, "stack", {
+      value: stack
+    });
+    setServerError(serverState, error);
+  };
+  return {
+    state: serverState,
+    onFileChange,
+    onHMRError
+  };
+}
+function createLoaderController(loader) {
+  const controller = createBaseController({
+    reload() {
+      loader.clientReload();
+    }
+  });
+  const baseOnFileChange = controller.onFileChange;
+  controller.onFileChange = (...args) => {
+    if (controller.state.state === "error") {
+      loader.eachModule((mod) => {
+        if (mod.ssrError) {
+          loader.invalidateModule(mod);
+        }
+      });
+    }
+    baseOnFileChange(...args);
+  };
+  loader.events.on("file-change", controller.onFileChange);
+  loader.events.on("hmr-error", controller.onHMRError);
+  return controller;
+}
+async function runWithErrorHandling({
+  controller: { state },
+  pathname,
+  run,
+  onError
+}) {
+  try {
+    await run();
+    clearRouteError(state, pathname);
+  } catch (err) {
+    const error = onError(err);
+    setRouteError(state, pathname, error);
+  }
+}
+export {
+  createBaseController,
+  createController,
+  createLoaderController,
+  runWithErrorHandling
+};

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

@@ -1,10 +1,3 @@
-import type * as vite from 'vite';
-import type { AstroSettings } from '../@types/astro';
-import { LogOptions } from '../core/logger/core.js';
-interface AstroPluginOptions {
-    settings: AstroSettings;
-    logging: LogOptions;
-}
-export declare function baseMiddleware(settings: AstroSettings, logging: LogOptions): vite.Connect.NextHandleFunction;
-export default function createPlugin({ settings, logging }: AstroPluginOptions): vite.Plugin;
-export {};
+export { createController, runWithErrorHandling } from './controller.js';
+export { default as vitePluginAstroServer } from './plugin.js';
+export { handleRequest } from './request.js';