astro 1.6.2 → 1.6.4

package/dist/core/dev/index.js

@@ -1,83 +1,11 @@
-import { performance } from "perf_hooks";
-import * as vite from "vite";
-import {
-  runHookConfigDone,
-  runHookConfigSetup,
-  runHookServerDone,
-  runHookServerSetup,
-  runHookServerStart
-} from "../../integrations/index.js";
-import { createVite } from "../create-vite.js";
-import { info, warn } from "../logger/core.js";
-import * as msg from "../messages.js";
-import { apply as applyPolyfill } from "../polyfill.js";
-async function dev(settings, options) {
-  var _a, _b;
-  const devStart = performance.now();
-  applyPolyfill();
-  await options.telemetry.record([]);
-  settings = await runHookConfigSetup({
-    settings,
-    command: "dev",
-    logging: options.logging,
-    isRestart: options.isRestart
-  });
-  const { host, port } = settings.config.server;
-  const { isRestart = false } = options;
-  const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
-  const viteConfig = await createVite(
-    {
-      mode: "development",
-      server: { host },
-      optimizeDeps: {
-        include: rendererClientEntries
-      },
-      define: {
-        "import.meta.env.BASE_URL": settings.config.base ? `'${settings.config.base}'` : "undefined"
-      }
-    },
-    { settings, logging: options.logging, mode: "dev" }
-  );
-  await runHookConfigDone({ settings, logging: options.logging });
-  const viteServer = await vite.createServer(viteConfig);
-  runHookServerSetup({ config: settings.config, server: viteServer, logging: options.logging });
-  await viteServer.listen(port);
-  const site = settings.config.site ? new URL(settings.config.base, settings.config.site) : void 0;
-  info(
-    options.logging,
-    null,
-    msg.serverStart({
-      startupTime: performance.now() - devStart,
-      resolvedUrls: viteServer.resolvedUrls || { local: [], network: [] },
-      host: settings.config.server.host,
-      site,
-      isRestart
-    })
-  );
-  const currentVersion = "1.6.2";
-  if (currentVersion.includes("-")) {
-    warn(options.logging, null, msg.prerelease({ currentVersion }));
-  }
-  if (((_b = (_a = viteConfig.server) == null ? void 0 : _a.fs) == null ? void 0 : _b.strict) === false) {
-    warn(options.logging, null, msg.fsStrictWarning());
-  }
-  const devServerAddressInfo = viteServer.httpServer.address();
-  await runHookServerStart({
-    config: settings.config,
-    address: devServerAddressInfo,
-    logging: options.logging
-  });
-  return {
-    address: devServerAddressInfo,
-    get watcher() {
-      return viteServer.watcher;
-    },
-    stop: async () => {
-      await viteServer.close();
-      await runHookServerDone({ config: settings.config, logging: options.logging });
-    }
-  };
-}
+import { createContainer, isStarted, runInContainer, startContainer } from "./container.js";
+import { default as default2 } from "./dev.js";
+import { createContainerWithAutomaticRestart } from "./restart.js";
 export {
-  dev as default
+  createContainer,
+  createContainerWithAutomaticRestart,
+  default2 as default,
+  isStarted,
+  runInContainer,
+  startContainer
 };

package/dist/core/dev/restart.d.ts

@@ -0,0 +1,25 @@
+import type { Container, CreateContainerParams } from './container';
+export declare function shouldRestartContainer({ settings, configFlag, configFlagPath, restartInFlight }: Container, changedFile: string): boolean;
+interface RestartContainerParams {
+    container: Container;
+    flags: any;
+    logMsg: string;
+    handleConfigError: (err: Error) => Promise<void> | void;
+    beforeRestart?: () => void;
+}
+export declare function restartContainer({ container, flags, logMsg, handleConfigError, beforeRestart, }: RestartContainerParams): Promise<{
+    container: Container;
+    error: Error | null;
+}>;
+export interface CreateContainerWithAutomaticRestart {
+    flags: any;
+    params: CreateContainerParams;
+    handleConfigError?: (error: Error) => void | Promise<void>;
+    beforeRestart?: () => void;
+}
+interface Restart {
+    container: Container;
+    restarted: () => Promise<Error | null>;
+}
+export declare function createContainerWithAutomaticRestart({ flags, handleConfigError, beforeRestart, params, }: CreateContainerWithAutomaticRestart): Promise<Restart>;
+export {};

package/dist/core/dev/restart.js

@@ -0,0 +1,143 @@
+import * as vite from "vite";
+import { createSettings, openConfig } from "../config/index.js";
+import { createSafeError } from "../errors/index.js";
+import { info } from "../logger/core.js";
+import { createContainer, isStarted, startContainer } from "./container.js";
+async function createRestartedContainer(container, settings, needsStart) {
+  const { logging, fs, resolvedRoot, configFlag, configFlagPath } = container;
+  const newContainer = await createContainer({
+    isRestart: true,
+    logging,
+    settings,
+    fs,
+    root: resolvedRoot,
+    configFlag,
+    configFlagPath
+  });
+  if (needsStart) {
+    await startContainer(newContainer);
+  }
+  return newContainer;
+}
+function shouldRestartContainer({ settings, configFlag, configFlagPath, restartInFlight }, changedFile) {
+  if (restartInFlight)
+    return false;
+  let shouldRestart = false;
+  if (configFlag) {
+    if (!!configFlagPath) {
+      shouldRestart = vite.normalizePath(configFlagPath) === vite.normalizePath(changedFile);
+    }
+  } else {
+    const exp = new RegExp(`.*astro.config.((mjs)|(cjs)|(js)|(ts))$`);
+    const normalizedChangedFile = vite.normalizePath(changedFile);
+    shouldRestart = exp.test(normalizedChangedFile);
+  }
+  if (!shouldRestart && settings.watchFiles.length > 0) {
+    shouldRestart = settings.watchFiles.some(
+      (path) => vite.normalizePath(path) === vite.normalizePath(changedFile)
+    );
+  }
+  return shouldRestart;
+}
+async function restartContainer({
+  container,
+  flags,
+  logMsg,
+  handleConfigError,
+  beforeRestart
+}) {
+  const { logging, close, resolvedRoot, settings: existingSettings } = container;
+  container.restartInFlight = true;
+  if (beforeRestart) {
+    beforeRestart();
+  }
+  const needsStart = isStarted(container);
+  try {
+    const newConfig = await openConfig({
+      cwd: resolvedRoot,
+      flags,
+      cmd: "dev",
+      logging,
+      isRestart: true,
+      fsMod: container.fs
+    });
+    info(logging, "astro", logMsg + "\n");
+    let astroConfig = newConfig.astroConfig;
+    const settings = createSettings(astroConfig, resolvedRoot);
+    await close();
+    return {
+      container: await createRestartedContainer(container, settings, needsStart),
+      error: null
+    };
+  } catch (_err) {
+    const error = createSafeError(_err);
+    await handleConfigError(error);
+    await close();
+    info(logging, "astro", "Continuing with previous valid configuration\n");
+    return {
+      container: await createRestartedContainer(container, existingSettings, needsStart),
+      error
+    };
+  }
+}
+async function createContainerWithAutomaticRestart({
+  flags,
+  handleConfigError = (_e) => {
+  },
+  beforeRestart,
+  params
+}) {
+  const initialContainer = await createContainer(params);
+  let resolveRestart;
+  let restartComplete = new Promise((resolve) => {
+    resolveRestart = resolve;
+  });
+  let restart = {
+    container: initialContainer,
+    restarted() {
+      return restartComplete;
+    }
+  };
+  function handleServerRestart(logMsg) {
+    const container = restart.container;
+    return async function(changedFile) {
+      if (shouldRestartContainer(container, changedFile)) {
+        const { container: newContainer, error } = await restartContainer({
+          beforeRestart,
+          container,
+          flags,
+          logMsg,
+          async handleConfigError(err) {
+            await handleConfigError(err);
+            container.viteServer.ws.send({
+              type: "error",
+              err: {
+                message: err.message,
+                stack: err.stack || ""
+              }
+            });
+          }
+        });
+        restart.container = newContainer;
+        addWatches();
+        resolveRestart(error);
+        restartComplete = new Promise((resolve) => {
+          resolveRestart = resolve;
+        });
+      }
+    };
+  }
+  function addWatches() {
+    const watcher = restart.container.viteServer.watcher;
+    watcher.on("change", handleServerRestart("Configuration updated. Restarting..."));
+    watcher.on("unlink", handleServerRestart("Configuration removed. Restarting..."));
+    watcher.on("add", handleServerRestart("Configuration added. Restarting..."));
+  }
+  addWatches();
+  return restart;
+}
+export {
+  createContainerWithAutomaticRestart,
+  restartContainer,
+  shouldRestartContainer
+};

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { EndpointHandler } from '../../@types/astro';
+import type { AstroConfig, EndpointHandler } from '../../@types/astro';
 import type { Environment, RenderContext } from '../render/index';
 import { AstroCookies } from '../cookies/index.js';
 declare type EndpointCallResult = {
@@ -12,4 +12,5 @@ declare type EndpointCallResult = {
     response: Response;
 };
 export declare function call(mod: EndpointHandler, env: Environment, ctx: RenderContext): Promise<EndpointCallResult>;
+export declare function throwIfRedirectNotAllowed(response: Response, config: AstroConfig): void;
 export {};

package/dist/core/endpoint/index.js

@@ -79,6 +79,17 @@ async function call(mod, env, ctx) {
     cookies: context.cookies
   };
 }
+function isRedirect(statusCode) {
+  return statusCode >= 300 && statusCode < 400;
+}
+function throwIfRedirectNotAllowed(response, config) {
+  if (config.output !== "server" && isRedirect(response.status)) {
+    throw new Error(
+      `Redirects are only available when using output: 'server'. Update your Astro config if you need SSR features.`
+    );
+  }
+}
 export {
-  call
+  call,
+  throwIfRedirectNotAllowed
 };

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

@@ -1,10 +1,11 @@
-import { type ErrorPayload, type Logger, type LogLevel, type ViteDevServer } from 'vite';
+import { type ErrorPayload, type Logger, type LogLevel } from 'vite';
+import type { ModuleLoader } from '../../module-loader/index.js';
 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;
+export declare function enhanceViteSSRError(error: Error, filePath?: URL, loader?: ModuleLoader): AstroError;
 /**
  * Generate a payload for Vite's error overlay
  */

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

@@ -1,8 +1,6 @@
 import * as fs from "fs";
 import { fileURLToPath } from "url";
-import {
-  createLogger
-} from "vite";
+import { createLogger } from "vite";
 import { AstroErrorCodes } from "../codes.js";
 import { AstroError } from "../errors.js";
 import { incompatPackageExp } from "./utils.js";
@@ -18,11 +16,11 @@ function createCustomViteLogger(logLevel) {
   };
   return logger;
 }
-function enhanceViteSSRError(error, filePath, viteServer) {
+function enhanceViteSSRError(error, filePath, loader) {
   var _a, _b;
-  if (viteServer) {
+  if (loader) {
     try {
-      viteServer.ssrFixStacktrace(error);
+      loader.fixStacktrace(error);
     } catch {
     }
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.6.2";
+  const version = "1.6.4";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -255,7 +255,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.6.2"}`
+        `v${"1.6.4"}`
       )} ${headline}`
     );
   }

package/dist/core/module-loader/index.d.ts

@@ -0,0 +1,3 @@
+export { createLoader } from './loader.js';
+export type { LoaderEvents, ModuleInfo, ModuleLoader, ModuleNode } from './loader.js';
+export { createViteLoader } from './vite.js';

package/dist/core/module-loader/index.js

@@ -0,0 +1,6 @@
+import { createLoader } from "./loader.js";
+import { createViteLoader } from "./vite.js";
+export {
+  createLoader,
+  createViteLoader
+};

package/dist/core/module-loader/loader.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import type * as fs from 'fs';
+import type TypedEmitter from '../../@types/typed-emitter';
+export declare type LoaderEvents = {
+    'file-add': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
+    'file-change': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
+    'file-unlink': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
+    'hmr-error': (msg: {
+        type: 'error';
+        err: {
+            message: string;
+            stack: string;
+        };
+    }) => void;
+};
+export declare type ModuleLoaderEventEmitter = TypedEmitter<LoaderEvents>;
+export interface ModuleLoader {
+    import: (src: string) => Promise<Record<string, any>>;
+    resolveId: (specifier: string, parentId: string | undefined) => Promise<string | undefined>;
+    getModuleById: (id: string) => ModuleNode | undefined;
+    getModulesByFile: (file: string) => Set<ModuleNode> | undefined;
+    getModuleInfo: (id: string) => ModuleInfo | null;
+    eachModule(callbackfn: (value: ModuleNode, key: string) => void): void;
+    invalidateModule(mod: ModuleNode): void;
+    fixStacktrace: (error: Error) => void;
+    clientReload: () => void;
+    webSocketSend: (msg: any) => void;
+    isHttps: () => boolean;
+    events: TypedEmitter<LoaderEvents>;
+}
+export interface ModuleNode {
+    id: string | null;
+    url: string;
+    ssrModule: Record<string, any> | null;
+    ssrError: Error | null;
+    importedModules: Set<ModuleNode>;
+}
+export interface ModuleInfo {
+    id: string;
+    meta?: Record<string, any>;
+}
+export declare function createLoader(overrides: Partial<ModuleLoader>): ModuleLoader;

package/dist/core/module-loader/loader.js

@@ -0,0 +1,39 @@
+import { EventEmitter } from "events";
+function createLoader(overrides) {
+  return {
+    import() {
+      throw new Error(`Not implemented`);
+    },
+    resolveId(id) {
+      return Promise.resolve(id);
+    },
+    getModuleById() {
+      return void 0;
+    },
+    getModulesByFile() {
+      return void 0;
+    },
+    getModuleInfo() {
+      return null;
+    },
+    eachModule() {
+      throw new Error(`Not implemented`);
+    },
+    invalidateModule() {
+    },
+    fixStacktrace() {
+    },
+    clientReload() {
+    },
+    webSocketSend() {
+    },
+    isHttps() {
+      return true;
+    },
+    events: new EventEmitter(),
+    ...overrides
+  };
+}
+export {
+  createLoader
+};

package/dist/core/module-loader/vite.d.ts

@@ -0,0 +1,3 @@
+import type * as vite from 'vite';
+import type { ModuleLoader } from './loader';
+export declare function createViteLoader(viteServer: vite.ViteDevServer): ModuleLoader;

package/dist/core/module-loader/vite.js

@@ -0,0 +1,62 @@
+import { EventEmitter } from "events";
+function createViteLoader(viteServer) {
+  const events = new EventEmitter();
+  viteServer.watcher.on("add", (...args) => events.emit("file-add", args));
+  viteServer.watcher.on("unlink", (...args) => events.emit("file-unlink", args));
+  viteServer.watcher.on("change", (...args) => events.emit("file-change", args));
+  wrapMethod(viteServer.ws, "send", (msg) => {
+    if ((msg == null ? void 0 : msg.type) === "error") {
+      events.emit("hmr-error", msg);
+    }
+  });
+  return {
+    import(src) {
+      return viteServer.ssrLoadModule(src);
+    },
+    async resolveId(spec, parent) {
+      const ret = await viteServer.pluginContainer.resolveId(spec, parent);
+      return ret == null ? void 0 : ret.id;
+    },
+    getModuleById(id) {
+      return viteServer.moduleGraph.getModuleById(id);
+    },
+    getModulesByFile(file) {
+      return viteServer.moduleGraph.getModulesByFile(file);
+    },
+    getModuleInfo(id) {
+      return viteServer.pluginContainer.getModuleInfo(id);
+    },
+    eachModule(cb) {
+      return viteServer.moduleGraph.idToModuleMap.forEach(cb);
+    },
+    invalidateModule(mod) {
+      viteServer.moduleGraph.invalidateModule(mod);
+    },
+    fixStacktrace(err) {
+      return viteServer.ssrFixStacktrace(err);
+    },
+    clientReload() {
+      viteServer.ws.send({
+        type: "full-reload",
+        path: "*"
+      });
+    },
+    webSocketSend(msg) {
+      return viteServer.ws.send(msg);
+    },
+    isHttps() {
+      return !!viteServer.config.server.https;
+    },
+    events
+  };
+}
+function wrapMethod(object, method, newFn) {
+  const orig = object[method];
+  object[method] = function(...args) {
+    newFn.apply(this, args);
+    return orig.apply(this, args);
+  };
+}
+export {
+  createViteLoader
+};

package/dist/core/preview/index.js

@@ -34,7 +34,8 @@ async function preview(_settings, { logging }) {
     client: settings.config.build.client,
     serverEntrypoint: new URL(settings.config.build.serverEntry, settings.config.build.server),
     host,
-    port
+    port,
+    base: settings.config.base
   });
   return server;
 }

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

@@ -1,7 +1,7 @@
-import type * as vite from 'vite';
+import type { ModuleLoader } from '../../module-loader/index';
 import { RuntimeMode } from '../../../@types/astro.js';
 /** Given a filePath URL, crawl Vite’s module graph to find all style imports. */
-export declare function getStylesForURL(filePath: URL, viteServer: vite.ViteDevServer, mode: RuntimeMode): Promise<{
+export declare function getStylesForURL(filePath: URL, loader: ModuleLoader, mode: RuntimeMode): Promise<{
     urls: Set<string>;
     stylesMap: Map<string, string>;
 }>;

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

@@ -2,13 +2,13 @@ import path from "path";
 import { viteID } from "../../util.js";
 import { STYLE_EXTENSIONS } from "../util.js";
 import { crawlGraph } from "./vite.js";
-async function getStylesForURL(filePath, viteServer, mode) {
+async function getStylesForURL(filePath, loader, mode) {
   const importedCssUrls = /* @__PURE__ */ new Set();
   const importedStylesMap = /* @__PURE__ */ new Map();
-  for await (const importedModule of crawlGraph(viteServer, viteID(filePath), true)) {
+  for await (const importedModule of crawlGraph(loader, viteID(filePath), true)) {
     const ext = path.extname(importedModule.url).toLowerCase();
     if (STYLE_EXTENSIONS.has(ext)) {
-      const ssrModule = importedModule.ssrModule ?? await viteServer.ssrLoadModule(importedModule.url);
+      const ssrModule = importedModule.ssrModule ?? await loader.import(importedModule.url);
       if (mode === "development" && typeof (ssrModule == null ? void 0 : ssrModule.default) === "string") {
         importedStylesMap.set(importedModule.url, ssrModule.default);
       } else {

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

@@ -1,9 +1,9 @@
-import type { ViteDevServer } from 'vite';
 import type { AstroSettings } from '../../../@types/astro';
 import type { LogOptions } from '../../logger/core.js';
+import type { ModuleLoader } from '../../module-loader/index';
 import type { Environment } from '../index';
 export declare type DevelopmentEnvironment = Environment & {
+    loader: ModuleLoader;
     settings: AstroSettings;
-    viteServer: ViteDevServer;
 };
-export declare function createDevelopmentEnvironment(settings: AstroSettings, logging: LogOptions, viteServer: ViteDevServer): DevelopmentEnvironment;
+export declare function createDevelopmentEnvironment(settings: AstroSettings, logging: LogOptions, loader: ModuleLoader): DevelopmentEnvironment;

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

@@ -1,7 +1,7 @@
 import { createEnvironment } from "../index.js";
 import { RouteCache } from "../route-cache.js";
 import { createResolve } from "./resolve.js";
-function createDevelopmentEnvironment(settings, logging, viteServer) {
+function createDevelopmentEnvironment(settings, logging, loader) {
   var _a;
   const mode = "development";
   let env = createEnvironment({
@@ -13,7 +13,7 @@ function createDevelopmentEnvironment(settings, logging, viteServer) {
     },
     mode,
     renderers: [],
-    resolve: createResolve(viteServer),
+    resolve: createResolve(loader),
     routeCache: new RouteCache(logging, mode),
     site: settings.config.site,
     ssr: settings.config.output === "server",
@@ -21,7 +21,7 @@ function createDevelopmentEnvironment(settings, logging, viteServer) {
   });
   return {
     ...env,
-    viteServer,
+    loader,
     settings
   };
 }

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

@@ -1,6 +1,6 @@
-import type { ViteDevServer } from 'vite';
 import type { AstroSettings, ComponentInstance, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../../@types/astro';
 import { LogOptions } from '../../logger/core.js';
+import type { ModuleLoader } from '../../module-loader/index';
 import { RouteCache } from '../route-cache.js';
 import type { DevelopmentEnvironment } from './environment';
 export { createDevelopmentEnvironment } from './environment.js';
@@ -22,8 +22,8 @@ export interface SSROptionsOld {
     route?: RouteData;
     /** pass in route cache because SSR can’t manage cache-busting */
     routeCache: RouteCache;
-    /** Vite instance */
-    viteServer: ViteDevServer;
+    /** Module loader (Vite) */
+    loader: ModuleLoader;
     /** Request */
     request: Request;
 }
@@ -44,6 +44,6 @@ export interface SSROptions {
     route?: RouteData;
 }
 export declare type ComponentPreload = [SSRLoadedRenderer[], ComponentInstance];
-export declare function loadRenderers(viteServer: ViteDevServer, settings: AstroSettings): Promise<SSRLoadedRenderer[]>;
+export declare function loadRenderers(moduleLoader: ModuleLoader, settings: AstroSettings): Promise<SSRLoadedRenderer[]>;
 export declare function preload({ env, filePath, }: Pick<SSROptions, 'env' | 'filePath'>): Promise<ComponentPreload>;
 export declare function renderPage(options: SSROptions): Promise<Response>;