astro 2.10.11 → 2.10.13

package/client-base.d.ts

@@ -53,6 +53,7 @@ declare module 'astro:assets' {
 				| import('./dist/assets/types.js').UnresolvedImageTransform
 		) => Promise<import('./dist/assets/types.js').GetImageResult>;
 		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
+		imageConfig: import('./dist/@types/astro').AstroConfig['image'];
 		Image: typeof import('./components/Image.astro').default;
 	};
 
@@ -69,7 +70,7 @@ declare module 'astro:assets' {
 	export type RemoteImageProps = Simplify<
 		import('./dist/assets/types.js').RemoteImageProps<ImgAttributes>
 	>;
-	export const { getImage, getConfiguredImageService, Image }: AstroAssets;
+	export const { getImage, getConfiguredImageService, imageConfig, Image }: AstroAssets;
 }
 
 declare module 'astro:transitions' {

package/components/ViewTransitions.astro

@@ -20,22 +20,21 @@ const { fallback = 'animate' } = Astro.props as Props;
 	type Events = 'astro:load' | 'astro:beforeload';
 
 	const persistState = (state: State) => history.replaceState(state, '');
+	const supportsViewTransitions = !!document.startViewTransition;
+	const transitionEnabledOnThisPage = () =>
+		!!document.querySelector('[name="astro-view-transitions-enabled"]');
+	const triggerEvent = (name: Events) => document.dispatchEvent(new Event(name));
+	const onload = () => triggerEvent('astro:load');
+	const PERSIST_ATTR = 'data-astro-transition-persist';
 
 	// The History API does not tell you if navigation is forward or back, so
 	// you can figure it using an index. On pushState the index is incremented so you
 	// can use that to determine popstate if going forward or back.
 	let currentHistoryIndex = history.state?.index || 0;
-	if (!history.state) {
+	if (!history.state && transitionEnabledOnThisPage()) {
 		persistState({ index: currentHistoryIndex, scrollY: 0 });
 	}
 
-	const supportsViewTransitions = !!document.startViewTransition;
-	const transitionEnabledOnThisPage = () =>
-		!!document.querySelector('[name="astro-view-transitions-enabled"]');
-	const triggerEvent = (name: Events) => document.dispatchEvent(new Event(name));
-	const onload = () => triggerEvent('astro:load');
-	const PERSIST_ATTR = 'data-astro-transition-persist';
-
 	const throttle = (cb: (...args: any[]) => any, delay: number) => {
 		let wait = false;
 		// During the waiting time additional events are lost.
@@ -165,14 +164,21 @@ const { fallback = 'animate' } = Astro.props as Props;
 				}
 			}
 
+			// Simulate scroll behavior of Safari and
+			// Chromium based browsers (Chrome, Edge, Opera, ...)
+			scrollTo({ left: 0, top: 0, behavior: 'instant' });
+
 			if (state?.scrollY === 0 && location.hash) {
 				const id = decodeURIComponent(location.hash.slice(1));
-				state.scrollY = document.getElementById(id)?.offsetTop || 0;
-			}
-			if (state?.scrollY != null) {
-				scrollTo(0, state.scrollY);
-				// Overwrite erroneous updates by the scroll handler during transition
-				persistState(state);
+				const elem = document.getElementById(id);
+				// prefer scrollIntoView() over scrollTo() because it takes scroll-padding into account
+				if (elem) {
+					state.scrollY = elem.offsetTop;
+					persistState(state); // first guess, later updated by scroll handler
+					elem.scrollIntoView(); // for Firefox, this should better be {behavior: 'instant'}
+				}
+			} else if (state && state.scrollY !== 0) {
+				scrollTo(0, state.scrollY); // usings default scrollBehavior
 			}
 
 			triggerEvent('astro:beforeload');
@@ -274,34 +280,59 @@ const { fallback = 'animate' } = Astro.props as Props;
 			// that is going to another page within the same origin. Basically it determines
 			// same-origin navigation, but omits special key combos for new tabs, etc.
 			if (
-				link &&
-				link instanceof HTMLAnchorElement &&
-				link.href &&
-				(!link.target || link.target === '_self') &&
-				link.origin === location.origin &&
-				!(
-					// Same page means same path and same query params
-					(location.pathname === link.pathname && location.search === link.search)
-				) &&
-				ev.button === 0 && // left clicks only
-				!ev.metaKey && // new tab (mac)
-				!ev.ctrlKey && // new tab (windows)
-				!ev.altKey && // download
-				!ev.shiftKey &&
-				!ev.defaultPrevented &&
-				transitionEnabledOnThisPage()
-			) {
-				ev.preventDefault();
-				navigate('forward', link.href, { index: ++currentHistoryIndex, scrollY: 0 });
-				const newState: State = { index: currentHistoryIndex, scrollY };
-				persistState({ index: currentHistoryIndex - 1, scrollY });
-				history.pushState(newState, '', link.href);
+				!link ||
+				!(link instanceof HTMLAnchorElement) ||
+				!link.href ||
+				(link.target && link.target !== '_self') ||
+				link.origin !== location.origin ||
+				ev.button !== 0 || // left clicks only
+				ev.metaKey || // new tab (mac)
+				ev.ctrlKey || // new tab (windows)
+				ev.altKey || // download
+				ev.shiftKey || // new window
+				ev.defaultPrevented ||
+				!transitionEnabledOnThisPage()
+			)
+				// No page transitions in these cases,
+				// Let the browser standard action handle this
+				return;
+
+			// We do not need to handle same page links because there are no page transitions
+			// Same page means same path and same query params (but different hash)
+			if (location.pathname === link.pathname && location.search === link.search) {
+				if (link.hash) {
+					// The browser default action will handle navigations with hash fragments
+					return;
+				} else {
+					// Special case: self link without hash
+					// If handed to the browser it will reload the page
+					// But we want to handle it like any other same page navigation
+					// So we scroll to the top of the page but do not start page transitions
+					ev.preventDefault();
+					persistState({ ...history.state, scrollY });
+					scrollTo({ left: 0, top: 0, behavior: 'instant' });
+					if (location.hash) {
+						// last target was different
+						const newState: State = { index: ++currentHistoryIndex, scrollY: 0 };
+						history.pushState(newState, '', link.href);
+					}
+					return;
+				}
 			}
+
+			// these are the cases we will handle: same origin, different page
+			ev.preventDefault();
+			navigate('forward', link.href, { index: ++currentHistoryIndex, scrollY: 0 });
+			const newState: State = { index: currentHistoryIndex, scrollY };
+			persistState({ index: currentHistoryIndex - 1, scrollY });
+			history.pushState(newState, '', link.href);
 		});
+
 		addEventListener('popstate', (ev) => {
-			if (!transitionEnabledOnThisPage()) {
+			if (!transitionEnabledOnThisPage() && ev.state) {
 				// The current page doesn't haven't View Transitions,
 				// respect that with a full page reload
+				// -- but only for transition managed by us (ev.state is set)
 				location.reload();
 				return;
 			}

package/content-types.template.d.ts

@@ -53,12 +53,9 @@ declare module 'astro:content' {
 
 	type BaseSchemaWithoutEffects =
 		| import('astro/zod').AnyZodObject
-		| import('astro/zod').ZodUnion<import('astro/zod').AnyZodObject[]>
+		| import('astro/zod').ZodUnion<[BaseSchemaWithoutEffects, ...BaseSchemaWithoutEffects[]]>
 		| import('astro/zod').ZodDiscriminatedUnion<string, import('astro/zod').AnyZodObject[]>
-		| import('astro/zod').ZodIntersection<
-				import('astro/zod').AnyZodObject,
-				import('astro/zod').AnyZodObject
-		  >;
+		| import('astro/zod').ZodIntersection<BaseSchemaWithoutEffects, BaseSchemaWithoutEffects>;
 
 	type BaseSchema =
 		| BaseSchemaWithoutEffects

package/dist/content/utils.js

@@ -142,7 +142,10 @@ function getDataEntryId({
   collection
 }) {
   const relativePath = getRelativeEntryPath(entry, collection, contentDir);
-  const withoutFileExt = relativePath.replace(new RegExp(path.extname(relativePath) + "$"), "");
+  const withoutFileExt = normalizePath(relativePath).replace(
+    new RegExp(path.extname(relativePath) + "$"),
+    ""
+  );
   return withoutFileExt;
 }
 function getContentEntryIdAndSlug({

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

@@ -375,7 +375,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
     legacy?: {} | undefined;
 }>;
 export type AstroConfigType = z.infer<typeof AstroConfigSchema>;
-export declare function createRelativeSchema(cmd: string, fileProtocolRoot: string): z.ZodEffects<z.ZodObject<{
+export declare function createRelativeSchema(cmd: string, fileProtocolRoot: string): z.ZodEffects<z.ZodEffects<z.ZodObject<{
     output: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"static">, z.ZodLiteral<"server">, z.ZodLiteral<"hybrid">]>>>;
     redirects: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
         status: z.ZodUnion<[z.ZodLiteral<300>, z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<303>, z.ZodLiteral<304>, z.ZodLiteral<307>, z.ZodLiteral<308>]>;
@@ -893,4 +893,149 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         optimizeHoistedScript?: boolean | undefined;
     } | undefined;
     legacy?: {} | undefined;
+}>, {
+    site?: string | undefined;
+    adapter?: {
+        name: string;
+        hooks: {};
+    } | undefined;
+    output: "server" | "static" | "hybrid";
+    server: {
+        headers?: OutgoingHttpHeaders | undefined;
+        host: string | boolean;
+        port: number;
+        open: boolean;
+        streaming: boolean;
+    };
+    redirects: Record<string, string | {
+        status: 300 | 301 | 302 | 303 | 304 | 307 | 308;
+        destination: string;
+    }>;
+    root: import("url").URL;
+    srcDir: import("url").URL;
+    publicDir: import("url").URL;
+    outDir: import("url").URL;
+    cacheDir: import("url").URL;
+    compressHTML: boolean;
+    base: string;
+    trailingSlash: "ignore" | "always" | "never";
+    scopedStyleStrategy: "where" | "class";
+    integrations: {
+        name: string;
+        hooks: {};
+    }[];
+    build: {
+        assetsPrefix?: string | undefined;
+        format: "file" | "directory";
+        client: import("url").URL;
+        server: import("url").URL;
+        assets: string;
+        serverEntry: string;
+        redirects: boolean;
+        inlineStylesheets: "always" | "never" | "auto";
+        split: boolean;
+        excludeMiddleware: boolean;
+    };
+    image: {
+        service: {
+            entrypoint: string;
+            config: Record<string, any>;
+        };
+        domains: string[];
+        remotePatterns: {
+            port?: string | undefined;
+            protocol?: string | undefined;
+            hostname?: string | undefined;
+            pathname?: string | undefined;
+        }[];
+    };
+    markdown: {
+        drafts: boolean;
+        syntaxHighlight: false | "shiki" | "prism";
+        shikiConfig: {
+            langs: ILanguageRegistration[];
+            theme: string | import("shiki").IShikiTheme;
+            wrap: boolean | null;
+        };
+        remarkPlugins: (string | [string, any] | RemarkPlugin | [RemarkPlugin, any])[];
+        rehypePlugins: (string | [string, any] | RehypePlugin | [RehypePlugin, any])[];
+        remarkRehype: RemarkRehype;
+        gfm: boolean;
+        smartypants: boolean;
+    };
+    vite: ViteUserConfig;
+    experimental: {
+        assets: boolean;
+        viewTransitions: boolean;
+        optimizeHoistedScript: boolean;
+    };
+    legacy: {};
+}, {
+    output?: "server" | "static" | "hybrid" | undefined;
+    server?: unknown;
+    redirects?: Record<string, string | {
+        status: 300 | 301 | 302 | 303 | 304 | 307 | 308;
+        destination: string;
+    }> | undefined;
+    root?: string | undefined;
+    srcDir?: string | undefined;
+    publicDir?: string | undefined;
+    outDir?: string | undefined;
+    cacheDir?: string | undefined;
+    site?: string | undefined;
+    compressHTML?: boolean | undefined;
+    base?: string | undefined;
+    trailingSlash?: "ignore" | "always" | "never" | undefined;
+    scopedStyleStrategy?: "where" | "class" | undefined;
+    adapter?: {
+        hooks?: {} | undefined;
+        name: string;
+    } | undefined;
+    integrations?: unknown;
+    build?: {
+        format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        server?: string | undefined;
+        assets?: string | undefined;
+        serverEntry?: string | undefined;
+        redirects?: boolean | undefined;
+        inlineStylesheets?: "always" | "never" | "auto" | undefined;
+        split?: boolean | undefined;
+        excludeMiddleware?: boolean | undefined;
+        assetsPrefix?: string | undefined;
+    } | undefined;
+    image?: {
+        domains?: string[] | undefined;
+        remotePatterns?: {
+            port?: string | undefined;
+            protocol?: string | undefined;
+            hostname?: string | undefined;
+            pathname?: string | undefined;
+        }[] | undefined;
+        service: {
+            config?: Record<string, any> | undefined;
+            entrypoint: string;
+        };
+    } | undefined;
+    markdown?: {
+        drafts?: boolean | undefined;
+        syntaxHighlight?: false | "shiki" | "prism" | undefined;
+        shikiConfig?: {
+            langs?: ILanguageRegistration[] | undefined;
+            theme?: string | import("shiki").IShikiTheme | undefined;
+            wrap?: boolean | null | undefined;
+        } | undefined;
+        remarkPlugins?: (string | [string, any] | RemarkPlugin | [RemarkPlugin, any])[] | undefined;
+        rehypePlugins?: (string | [string, any] | RehypePlugin | [RehypePlugin, any])[] | undefined;
+        remarkRehype?: RemarkRehype | undefined;
+        gfm?: boolean | undefined;
+        smartypants?: boolean | undefined;
+    } | undefined;
+    vite?: ViteUserConfig | undefined;
+    experimental?: {
+        assets?: boolean | undefined;
+        viewTransitions?: boolean | undefined;
+        optimizeHoistedScript?: boolean | undefined;
+    } | undefined;
+    legacy?: {} | undefined;
 }>;

package/dist/core/config/schema.js

@@ -245,6 +245,8 @@ A future version of Astro will stop using the site pathname when producing <link
       config.base = prependForwardSlash(appendForwardSlash(trimmedBase));
     }
     return config;
+  }).refine((obj) => !obj.outDir.toString().startsWith(obj.publicDir.toString()), {
+    message: "`outDir` must not be placed inside `publicDir` to prevent an infinite loop. Please adjust the directory configuration and try again"
   });
   return AstroConfigRelativeSchema;
 }

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.10.11";
+const ASTRO_VERSION = "2.10.13";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -23,7 +23,7 @@ async function dev(inlineConfig) {
       base: restart.container.settings.config.base
     })
   );
-  const currentVersion = "2.10.11";
+  const currentVersion = "2.10.13";
   if (currentVersion.includes("-")) {
     warn(logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.10.11";
+  const version = "2.10.13";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.10.11"}`
+        `v${"2.10.13"}`
       )} ${headline}`
     );
   }

package/dist/runtime/server/render/any.js

@@ -2,6 +2,7 @@ import { escapeHTML, isHTMLString, markHTMLString } from "../escape.js";
 import { isAstroComponentInstance, isRenderTemplateResult } from "./astro/index.js";
 import { isRenderInstance } from "./common.js";
 import { SlotString } from "./slot.js";
+import { renderToBufferDestination } from "./util.js";
 async function renderChild(destination, child) {
   child = await child;
   if (child instanceof SlotString) {
@@ -9,8 +10,13 @@ async function renderChild(destination, child) {
   } else if (isHTMLString(child)) {
     destination.write(child);
   } else if (Array.isArray(child)) {
-    for (const c of child) {
-      await renderChild(destination, c);
+    const childRenders = child.map((c) => {
+      return renderToBufferDestination((bufferDestination) => {
+        return renderChild(bufferDestination, c);
+      });
+    });
+    for (const childRender of childRenders) {
+      await childRender.renderToFinalDestination(destination);
     }
   } else if (typeof child === "function") {
     await renderChild(destination, child());

package/dist/runtime/server/render/astro/render-template.js

@@ -2,6 +2,7 @@ var _a;
 import { markHTMLString } from "../../escape.js";
 import { isPromise } from "../../util.js";
 import { renderChild } from "../any.js";
+import { renderToBufferDestination } from "../util.js";
 const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
 class RenderTemplateResult {
   constructor(htmlParts, expressions) {
@@ -21,12 +22,19 @@ class RenderTemplateResult {
     });
   }
   async render(destination) {
+    const expRenders = this.expressions.map((exp) => {
+      return renderToBufferDestination((bufferDestination) => {
+        if (exp || exp === 0) {
+          return renderChild(bufferDestination, exp);
+        }
+      });
+    });
     for (let i = 0; i < this.htmlParts.length; i++) {
       const html = this.htmlParts[i];
-      const exp = this.expressions[i];
+      const expRender = expRenders[i];
       destination.write(markHTMLString(html));
-      if (exp || exp === 0) {
-        await renderChild(destination, exp);
+      if (expRender) {
+        await expRender.renderToFinalDestination(destination);
       }
     }
   }

package/dist/runtime/server/render/common.d.ts

@@ -18,8 +18,9 @@ export interface RenderDestination {
     write(chunk: RenderDestinationChunk): void;
 }
 export interface RenderInstance {
-    render(destination: RenderDestination): Promise<void> | void;
+    render: RenderFunction;
 }
+export type RenderFunction = (destination: RenderDestination) => Promise<void> | void;
 export declare const Fragment: unique symbol;
 export declare const Renderer: unique symbol;
 export declare const encoder: TextEncoder;

package/dist/runtime/server/render/component.js

@@ -322,19 +322,9 @@ async function renderHTMLComponent(result, Component, _props, slots = {}) {
 }
 function renderAstroComponent(result, displayName, Component, props, slots = {}) {
   const instance = createAstroComponentInstance(result, displayName, Component, props, slots);
-  const bufferChunks = [];
-  const bufferDestination = {
-    write: (chunk) => bufferChunks.push(chunk)
-  };
-  const renderPromise = instance.render(bufferDestination);
   return {
     async render(destination) {
-      for (const chunk of bufferChunks) {
-        destination.write(chunk);
-      }
-      bufferChunks.length = 0;
-      bufferDestination.write = (chunk) => destination.write(chunk);
-      await renderPromise;
+      await instance.render(destination);
     }
   };
 }

package/dist/runtime/server/render/util.d.ts

@@ -1,4 +1,5 @@
 import type { SSRElement } from '../../../@types/astro';
+import type { RenderFunction } from './common.js';
 export declare const voidElementNames: RegExp;
 export declare const toAttributeString: (value: any, shouldEscape?: boolean) => any;
 export declare function defineScriptVars(vars: Record<any, any>): any;
@@ -6,3 +7,25 @@ export declare function formatList(values: string[]): string;
 export declare function addAttribute(value: any, key: string, shouldEscape?: boolean): any;
 export declare function internalSpreadAttributes(values: Record<any, any>, shouldEscape?: boolean): any;
 export declare function renderElement(name: string, { props: _props, children }: SSRElement, shouldEscape?: boolean): string;
+/**
+ * Executes the `bufferRenderFunction` to prerender it into a buffer destination, and return a promise
+ * with an object containing the `renderToFinalDestination` function to flush the buffer to the final
+ * destination.
+ *
+ * @example
+ * ```ts
+ * // Render components in parallel ahead of time
+ * const finalRenders = [ComponentA, ComponentB].map((comp) => {
+ *   return renderToBufferDestination(async (bufferDestination) => {
+ *     await renderComponentToDestination(bufferDestination);
+ *   });
+ * });
+ * // Render array of components serially
+ * for (const finalRender of finalRenders) {
+ *   await finalRender.renderToFinalDestination(finalDestination);
+ * }
+ * ```
+ */
+export declare function renderToBufferDestination(bufferRenderFunction: RenderFunction): {
+    renderToFinalDestination: RenderFunction;
+};

package/dist/runtime/server/render/util.js

@@ -103,12 +103,29 @@ function renderElement(name, { props: _props, children = "" }, shouldEscape = tr
   }
   return `<${name}${internalSpreadAttributes(props, shouldEscape)}>${children}</${name}>`;
 }
+function renderToBufferDestination(bufferRenderFunction) {
+  const bufferChunks = [];
+  const bufferDestination = {
+    write: (chunk) => bufferChunks.push(chunk)
+  };
+  const renderPromise = bufferRenderFunction(bufferDestination);
+  return {
+    async renderToFinalDestination(destination) {
+      for (const chunk of bufferChunks) {
+        destination.write(chunk);
+      }
+      bufferDestination.write = (chunk) => destination.write(chunk);
+      await renderPromise;
+    }
+  };
+}
 export {
   addAttribute,
   defineScriptVars,
   formatList,
   internalSpreadAttributes,
   renderElement,
+  renderToBufferDestination,
   toAttributeString,
   voidElementNames
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.10.11",
+  "version": "2.10.13",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",