astro 1.4.7 → 1.5.1

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

@@ -1,50 +1,35 @@
 import { fileURLToPath } from "url";
 import { PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
 import { isPage, resolveIdToUrl } from "../../util.js";
-import { render as coreRender } from "../core.js";
+import { createRenderContext, renderPage as coreRenderPage } from "../index.js";
+import { filterFoundRenderers, loadRenderer } from "../renderer.js";
 import { collectMdMetadata } from "../util.js";
 import { getStylesForURL } from "./css.js";
 import { getScriptsForURL } from "./scripts.js";
-const svelteStylesRE = /svelte\?svelte&type=style/;
-async function loadRenderer(viteServer, renderer) {
-  const mod = await viteServer.ssrLoadModule(renderer.serverEntrypoint);
-  return { ...renderer, ssr: mod.default };
-}
+import { createDevelopmentEnvironment } from "./environment.js";
 async function loadRenderers(viteServer, settings) {
-  return Promise.all(settings.renderers.map((r) => loadRenderer(viteServer, r)));
+  const loader = (entry) => viteServer.ssrLoadModule(entry);
+  const renderers = await Promise.all(settings.renderers.map((r) => loadRenderer(r, loader)));
+  return filterFoundRenderers(renderers);
 }
 async function preload({
-  settings,
-  filePath,
-  viteServer
+  env,
+  filePath
 }) {
-  const renderers = await loadRenderers(viteServer, settings);
-  const mod = await viteServer.ssrLoadModule(fileURLToPath(filePath));
-  if (viteServer.config.mode === "development" || !(mod == null ? void 0 : mod.$$metadata)) {
+  const renderers = await loadRenderers(env.viteServer, env.settings);
+  const mod = await env.viteServer.ssrLoadModule(fileURLToPath(filePath));
+  if (env.viteServer.config.mode === "development" || !(mod == null ? void 0 : mod.$$metadata)) {
     return [renderers, mod];
   }
-  const modGraph = await viteServer.moduleGraph.getModuleByUrl(fileURLToPath(filePath));
+  const modGraph = await env.viteServer.moduleGraph.getModuleByUrl(fileURLToPath(filePath));
   if (modGraph) {
-    await collectMdMetadata(mod.$$metadata, modGraph, viteServer);
+    await collectMdMetadata(mod.$$metadata, modGraph, env.viteServer);
   }
   return [renderers, mod];
 }
-async function render(renderers, mod, ssrOpts) {
-  var _a;
-  const {
-    settings,
-    filePath,
-    logging,
-    mode,
-    origin,
-    pathname,
-    request,
-    route,
-    routeCache,
-    viteServer
-  } = ssrOpts;
-  const scripts = await getScriptsForURL(filePath, viteServer);
-  if (isPage(filePath, settings) && mode === "development") {
+async function getScriptsAndStyles({ env, filePath }) {
+  const scripts = await getScriptsForURL(filePath, env.viteServer);
+  if (isPage(filePath, env.settings) && env.mode === "development") {
     scripts.add({
       props: { type: "module", src: "/@vite/client" },
       children: ""
@@ -52,25 +37,25 @@ async function render(renderers, mod, ssrOpts) {
     scripts.add({
       props: {
         type: "module",
-        src: await resolveIdToUrl(viteServer, "astro/runtime/client/hmr.js")
+        src: await resolveIdToUrl(env.viteServer, "astro/runtime/client/hmr.js")
       },
       children: ""
     });
   }
-  for (const script of settings.scripts) {
+  for (const script of env.settings.scripts) {
     if (script.stage === "head-inline") {
       scripts.add({
         props: {},
         children: script.content
       });
-    } else if (script.stage === "page" && isPage(filePath, settings)) {
+    } else if (script.stage === "page" && isPage(filePath, env.settings)) {
       scripts.add({
         props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
         children: ""
       });
     }
   }
-  const { urls: styleUrls, stylesMap } = await getStylesForURL(filePath, viteServer, mode);
+  const { urls: styleUrls, stylesMap } = await getStylesForURL(filePath, env.viteServer, env.mode);
   let links = /* @__PURE__ */ new Set();
   [...styleUrls].forEach((href) => {
     links.add({
@@ -95,45 +80,29 @@ async function render(renderers, mod, ssrOpts) {
       children: content
     });
   });
-  let response = await coreRender({
-    adapterName: (_a = settings.config.adapter) == null ? void 0 : _a.name,
+  return { scripts, styles, links };
+}
+async function renderPage(options) {
+  const [renderers, mod] = options.preload;
+  options.env.renderers = renderers;
+  const { scripts, links, styles } = await getScriptsAndStyles({
+    env: options.env,
+    filePath: options.filePath
+  });
+  const ctx = createRenderContext({
+    request: options.request,
+    origin: options.origin,
+    pathname: options.pathname,
+    scripts,
     links,
     styles,
-    logging,
-    markdown: {
-      ...settings.config.markdown,
-      isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
-    },
-    mod,
-    mode,
-    origin,
-    pathname,
-    scripts,
-    async resolve(s) {
-      const url = await resolveIdToUrl(viteServer, s);
-      if (url.startsWith("/@fs") && url.endsWith(".jsx")) {
-        return url.slice(0, -4);
-      } else {
-        return url;
-      }
-    },
-    renderers,
-    request,
-    route,
-    routeCache,
-    site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : void 0,
-    ssr: settings.config.output === "server",
-    streaming: true
+    route: options.route
   });
-  return response;
-}
-async function ssr(preloadedComponent, ssrOpts) {
-  const [renderers, mod] = preloadedComponent;
-  return await render(renderers, mod, ssrOpts);
+  return await coreRenderPage(mod, ctx, options.env);
 }
 export {
+  createDevelopmentEnvironment,
   loadRenderers,
   preload,
-  render,
-  ssr
+  renderPage
 };

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

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from 'vite';
+export declare function createResolve(viteServer: ViteDevServer): (s: string) => Promise<string>;

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

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

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

@@ -0,0 +1,29 @@
+import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
+import type { RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
+import type { LogOptions } from '../logger/core.js';
+import { RouteCache } from './route-cache.js';
+/**
+ * An environment represents the static parts of rendering that do not change
+ * between requests. These are mostly known when the server first starts up and do not change.
+ * Thus they can be created once and passed through to renderPage on each request.
+ */
+export interface Environment {
+    adapterName?: string;
+    /** logging options */
+    logging: LogOptions;
+    markdown: MarkdownRenderingOptions;
+    /** "development" or "production" */
+    mode: RuntimeMode;
+    renderers: SSRLoadedRenderer[];
+    resolve: (s: string) => Promise<string>;
+    routeCache: RouteCache;
+    site?: string;
+    ssr: boolean;
+    streaming: boolean;
+}
+export declare type CreateEnvironmentArgs = Environment;
+export declare function createEnvironment(options: CreateEnvironmentArgs): Environment;
+export declare type CreateBasicEnvironmentArgs = Partial<Environment> & {
+    logging: CreateEnvironmentArgs['logging'];
+};
+export declare function createBasicEnvironment(options: CreateBasicEnvironmentArgs): Environment;

package/dist/core/render/environment.js

@@ -0,0 +1,21 @@
+import { RouteCache } from "./route-cache.js";
+function createEnvironment(options) {
+  return options;
+}
+function createBasicEnvironment(options) {
+  const mode = options.mode ?? "development";
+  return createEnvironment({
+    ...options,
+    markdown: options.markdown ?? {},
+    mode,
+    renderers: options.renderers ?? [],
+    resolve: options.resolve ?? ((s) => Promise.resolve(s)),
+    routeCache: new RouteCache(options.logging, mode),
+    ssr: options.ssr ?? true,
+    streaming: options.streaming ?? true
+  });
+}
+export {
+  createBasicEnvironment,
+  createEnvironment
+};

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

@@ -0,0 +1,6 @@
+export type { RenderContext } from './context';
+export { createRenderContext } from './context.js';
+export { getParamsAndProps, GetParamsAndPropsError, renderPage } from './core.js';
+export type { Environment } from './environment';
+export { createBasicEnvironment, createEnvironment } from './environment.js';
+export { loadRenderer } from './renderer.js';

package/dist/core/render/index.js

@@ -0,0 +1,13 @@
+import { createRenderContext } from "./context.js";
+import { getParamsAndProps, GetParamsAndPropsError, renderPage } from "./core.js";
+import { createBasicEnvironment, createEnvironment } from "./environment.js";
+import { loadRenderer } from "./renderer.js";
+export {
+  GetParamsAndPropsError,
+  createBasicEnvironment,
+  createEnvironment,
+  createRenderContext,
+  getParamsAndProps,
+  loadRenderer,
+  renderPage
+};

package/dist/core/render/renderer.d.ts

@@ -0,0 +1,9 @@
+import type { AstroRenderer, SSRLoadedRenderer } from '../../@types/astro';
+export declare type RendererServerEntrypointModule = {
+    default: SSRLoadedRenderer['ssr'];
+};
+export declare type MaybeRendererServerEntrypointModule = Partial<RendererServerEntrypointModule>;
+export declare type RendererLoader = (entryPoint: string) => Promise<MaybeRendererServerEntrypointModule>;
+export declare function loadRenderer(renderer: AstroRenderer, loader: RendererLoader): Promise<SSRLoadedRenderer | undefined>;
+export declare function filterFoundRenderers(renderers: Array<SSRLoadedRenderer | undefined>): SSRLoadedRenderer[];
+export declare function createLoadedRenderer(renderer: AstroRenderer, mod: RendererServerEntrypointModule): SSRLoadedRenderer;

package/dist/core/render/renderer.js

@@ -0,0 +1,23 @@
+async function loadRenderer(renderer, loader) {
+  const mod = await loader(renderer.serverEntrypoint);
+  if (typeof mod.default !== "undefined") {
+    return createLoadedRenderer(renderer, mod);
+  }
+  return void 0;
+}
+function filterFoundRenderers(renderers) {
+  return renderers.filter((renderer) => {
+    return !!renderer;
+  });
+}
+function createLoadedRenderer(renderer, mod) {
+  return {
+    ...renderer,
+    ssr: mod.default
+  };
+}
+export {
+  createLoadedRenderer,
+  filterFoundRenderers,
+  loadRenderer
+};

package/dist/core/render/result.js

@@ -116,7 +116,7 @@ _slots = new WeakMap();
 _loggingOpts = new WeakMap();
 let renderMarkdown = null;
 function createResult(args) {
-  const { markdown, params, pathname, props: pageProps, renderers, request, resolve } = args;
+  const { markdown, params, pathname, renderers, request, resolve } = args;
   const url = new URL(request.url);
   const headers = new Headers();
   headers.set("Content-Type", "text/html");
@@ -166,9 +166,9 @@ function createResult(args) {
         props,
         request,
         url,
-        redirect: args.ssr ? (path) => {
+        redirect: args.ssr ? (path, status) => {
           return new Response(null, {
-            status: 302,
+            status: status || 302,
             headers: {
               Location: path
             }

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

@@ -36,10 +36,19 @@ function getParts(part, file) {
 }
 function getPattern(segments, addTrailingSlash) {
   const pathname = segments.map((segment) => {
-    return segment[0].spread ? "(?:\\/(.*?))?" : "\\/" + segment.map((part) => {
-      if (part)
-        return part.dynamic ? "([^/]+?)" : part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }).join("");
+    if (segment.length === 1 && segment[0].spread) {
+      return "(?:\\/(.*?))?";
+    } else {
+      return "\\/" + segment.map((part) => {
+        if (part.spread) {
+          return "(.*?)";
+        } else if (part.dynamic) {
+          return "([^/]+?)";
+        } else {
+          return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+      }).join("");
+    }
   }).join("");
   const trailing = addTrailingSlash && segments.length ? getTrailingSlashPattern(addTrailingSlash) : "$";
   return new RegExp(`^${pathname || "\\/"}${trailing}`);
@@ -71,7 +80,7 @@ function validateSegment(segment, file = "") {
   if (countOccurrences("[", segment) !== countOccurrences("]", segment)) {
     throw new Error(`Invalid route ${file} \u2014 brackets are unbalanced`);
   }
-  if (/.+\[\.\.\.[^\]]+\]/.test(segment) || /\[\.\.\.[^\]]+\].+/.test(segment)) {
+  if ((/.+\[\.\.\.[^\]]+\]/.test(segment) || /\[\.\.\.[^\]]+\].+/.test(segment)) && file.endsWith(".astro")) {
     throw new Error(`Invalid route ${file} \u2014 rest parameter must be a standalone segment`);
   }
 }

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

@@ -1,9 +1,14 @@
 import { compile } from "path-to-regexp";
 function getRouteGenerator(segments, addTrailingSlash) {
   const template = segments.map((segment) => {
-    return segment[0].spread ? `/:${segment[0].content.slice(3)}(.*)?` : "/" + segment.map((part) => {
-      if (part)
-        return part.dynamic ? `:${part.content}` : part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return "/" + segment.map((part) => {
+      if (part.spread) {
+        return `:${part.content.slice(3)}(.*)?`;
+      } else if (part.dynamic) {
+        return `:${part.content}`;
+      } else {
+        return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
     }).join("");
   }).join("");
   let trailing = "";

package/dist/core/util.d.ts

@@ -1,9 +1,9 @@
-/// <reference types="node" />
 import type { ErrorPayload, ViteDevServer } from 'vite';
 import type { AstroConfig, AstroSettings, RouteType } from '../@types/astro';
-export declare const ASTRO_VERSION: string;
 /** 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;
 /** Wraps an object in an array. If an array is passed, ignore it. */
 export declare function arraify<T>(target: T | T[]): T[];
 export declare function padMultilineString(source: string, n?: number): string;
@@ -45,15 +45,4 @@ export declare function getLocalAddress(serverAddress: string, host: string | bo
  */
 export declare function resolveIdToUrl(viteServer: ViteDevServer, id: string): Promise<string>;
 export declare function resolveJsToTs(filePath: string): string;
-export declare const AggregateError: AggregateErrorConstructor | {
-    new (errors: Iterable<any>, message?: string | undefined): {
-        errors: Array<any>;
-        name: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
+export declare const AggregateError: any;

package/dist/core/util.js

@@ -5,10 +5,12 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.4.7";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }
+function isURL(value) {
+  return Object.prototype.toString.call(value) === "[object URL]";
+}
 function arraify(target) {
   return Array.isArray(target) ? target : [target];
 }
@@ -175,7 +177,6 @@ const AggregateError = typeof globalThis.AggregateError !== "undefined" ? global
   }
 };
 export {
-  ASTRO_VERSION,
   AggregateError,
   VALID_ID_PREFIX,
   arraify,
@@ -187,6 +188,7 @@ export {
   isModeServerWithNoAdapter,
   isObject,
   isPage,
+  isURL,
   padMultilineString,
   parseNpmName,
   relativeToSrcDir,

package/dist/events/index.js

@@ -1,6 +1,6 @@
 import { AstroTelemetry } from "@astrojs/telemetry";
 import { createRequire } from "module";
-import { ASTRO_VERSION } from "../core/util.js";
+import { ASTRO_VERSION } from "../core/constants.js";
 const require2 = createRequire(import.meta.url);
 function getViteVersion() {
   try {

package/dist/integrations/index.d.ts

@@ -5,10 +5,11 @@ import { AstroConfig, AstroSettings, BuildConfig, RouteData } from '../@types/as
 import type { SerializedSSRManifest } from '../core/app/types';
 import type { PageBuildData } from '../core/build/types';
 import { LogOptions } from '../core/logger/core.js';
-export declare function runHookConfigSetup({ settings, command, logging, }: {
+export declare function runHookConfigSetup({ settings, command, logging, isRestart, }: {
     settings: AstroSettings;
-    command: 'dev' | 'build';
+    command: 'dev' | 'build' | 'preview';
     logging: LogOptions;
+    isRestart?: boolean;
 }): Promise<AstroSettings>;
 export declare function runHookConfigDone({ settings, logging, }: {
     settings: AstroSettings;

package/dist/integrations/index.js

@@ -1,6 +1,7 @@
 import { bold } from "kleur/colors";
+import { fileURLToPath } from "node:url";
 import { mergeConfig } from "../core/config/config.js";
-import { info } from "../core/logger/core.js";
+import { info, warn } from "../core/logger/core.js";
 async function withTakingALongTimeMsg({
   name,
   hookResult,
@@ -17,7 +18,8 @@ async function withTakingALongTimeMsg({
 async function runHookConfigSetup({
   settings,
   command,
-  logging
+  logging,
+  isRestart = false
 }) {
   var _a;
   if (settings.config.adapter) {
@@ -35,6 +37,7 @@ async function runHookConfigSetup({
       const hooks = {
         config: updatedConfig,
         command,
+        isRestart,
         addRenderer(renderer) {
           if (!renderer.name) {
             throw new Error(`Integration ${bold(integration.name)} has an unnamed renderer.`);
@@ -52,6 +55,9 @@ async function runHookConfigSetup({
         },
         injectRoute: (injectRoute) => {
           updatedSettings.injectedRoutes.push(injectRoute);
+        },
+        addWatchFile: (path) => {
+          updatedSettings.watchFiles.push(path instanceof URL ? fileURLToPath(path) : path);
         }
       };
       Object.defineProperty(hooks, "addPageExtension", {
@@ -147,13 +153,44 @@ async function runHookBuildStart({
   logging
 }) {
   var _a;
+  function warnDeprecated(integration, prop) {
+    let value = Reflect.get(buildConfig, prop);
+    Object.defineProperty(buildConfig, prop, {
+      enumerable: true,
+      get() {
+        return value;
+      },
+      set(newValue) {
+        value = newValue;
+        warn(
+          logging,
+          "astro:build:start",
+          `Your adapter ${bold(integration.name)} is using a deprecated API, buildConfig. ${bold(
+            prop
+          )} config should be set via config.build.${prop} instead.`
+        );
+      }
+    });
+    return () => {
+      Object.defineProperty(buildConfig, prop, {
+        enumerable: true,
+        value
+      });
+    };
+  }
   for (const integration of config.integrations) {
     if ((_a = integration == null ? void 0 : integration.hooks) == null ? void 0 : _a["astro:build:start"]) {
+      const undoClientWarning = warnDeprecated(integration, "client");
+      const undoServerWarning = warnDeprecated(integration, "server");
+      const undoServerEntryWarning = warnDeprecated(integration, "serverEntry");
       await withTakingALongTimeMsg({
         name: integration.name,
         hookResult: integration.hooks["astro:build:start"]({ buildConfig }),
         logging
       });
+      undoClientWarning();
+      undoServerEntryWarning();
+      undoServerWarning();
     }
   }
 }

package/dist/jsx/component.d.ts

@@ -0,0 +1 @@
+export declare function createAstroJSXComponent(factory: (...args: any[]) => any): (...args: any[]) => any;

package/dist/jsx/component.js

@@ -0,0 +1,10 @@
+import { __astro_tag_component__ } from "../runtime/server/index.js";
+import renderer from "./renderer.js";
+const ASTRO_JSX_RENDERER_NAME = renderer.name;
+function createAstroJSXComponent(factory) {
+  __astro_tag_component__(factory, ASTRO_JSX_RENDERER_NAME);
+  return factory;
+}
+export {
+  createAstroJSXComponent
+};

package/dist/jsx/index.d.ts

@@ -0,0 +1,2 @@
+export { createAstroJSXComponent } from './component.js';
+export { default as renderer } from './renderer.js';

package/dist/jsx/index.js

@@ -0,0 +1,6 @@
+import { createAstroJSXComponent } from "./component.js";
+import { default as default2 } from "./renderer.js";
+export {
+  createAstroJSXComponent,
+  default2 as renderer
+};

package/dist/jsx-runtime/index.js

@@ -1,7 +1,7 @@
 import { Fragment, markHTMLString, Renderer } from "../runtime/server/index.js";
 const AstroJSX = "astro:jsx";
 const Empty = Symbol("empty");
-const toSlotName = (str) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase());
+const toSlotName = (slotAttr) => slotAttr;
 function isVNode(vnode) {
   return vnode && typeof vnode === "object" && vnode[AstroJSX];
 }

package/dist/runtime/server/astro-global.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.4.7";
+import { ASTRO_VERSION } from "../../core/constants.js";
 function createDeprecatedFetchContentFn() {
   return () => {
     throw new Error("Deprecated: Astro.fetchContent() has been replaced with Astro.glob().");

package/dist/runtime/server/index.d.ts

@@ -1,6 +1,7 @@
 export { createAstro } from './astro-global.js';
 export { renderEndpoint } from './endpoint.js';
 export { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from './escape.js';
+export { renderJSX } from './jsx.js';
 export type { Metadata } from './metadata';
 export { createMetadata } from './metadata.js';
 export { addAttribute, defineScriptVars, Fragment, maybeRenderHead, renderAstroComponent, renderComponent, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderSlot, renderTemplate as render, renderTemplate, renderToString, stringifyChunk, voidElementNames, } from './render/index.js';

package/dist/runtime/server/index.js

@@ -1,6 +1,7 @@
 import { createAstro } from "./astro-global.js";
 import { renderEndpoint } from "./endpoint.js";
 import { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from "./escape.js";
+import { renderJSX } from "./jsx.js";
 import { createMetadata } from "./metadata.js";
 import {
   addAttribute,
@@ -101,6 +102,7 @@ export {
   renderEndpoint,
   renderHTMLElement,
   renderHead,
+  renderJSX,
   renderPage,
   renderSlot,
   renderTemplate2 as renderTemplate,