astro 5.7.2 → 5.7.4

package/dist/actions/runtime/virtual/server.js

@@ -160,13 +160,15 @@ function getActionContext(context) {
           }
           throw e;
         }
-        const {
-          props: _props,
-          getActionResult: _getActionResult,
-          callAction: _callAction,
-          redirect: _redirect,
-          ...actionAPIContext
-        } = context;
+        const omitKeys = ["props", "getActionResult", "callAction", "redirect"];
+        const actionAPIContext = Object.create(
+          Object.getPrototypeOf(context),
+          Object.fromEntries(
+            Object.entries(Object.getOwnPropertyDescriptors(context)).filter(
+              ([key]) => !omitKeys.includes(key)
+            )
+          )
+        );
         Reflect.set(actionAPIContext, ACTION_API_CONTEXT_SYMBOL, true);
         const handler = baseAction.bind(actionAPIContext);
         return handler(input);

package/dist/assets/fonts/constants.d.ts

@@ -11,6 +11,7 @@ export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
 export declare const URL_PREFIX = "/_astro/fonts/";
 export declare const CACHE_DIR = "./fonts/";
 export declare const FONT_TYPES: readonly ["woff2", "woff", "otf", "ttf", "eot"];
+export declare const FONT_FORMAT_MAP: Record<(typeof FONT_TYPES)[number], string>;
 export declare const SYSTEM_METRICS: {
     'Times New Roman': {
         ascent: number;

package/dist/assets/fonts/constants.js

@@ -12,6 +12,13 @@ const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
 const URL_PREFIX = "/_astro/fonts/";
 const CACHE_DIR = "./fonts/";
 const FONT_TYPES = ["woff2", "woff", "otf", "ttf", "eot"];
+const FONT_FORMAT_MAP = {
+  woff2: "woff2",
+  woff: "woff",
+  otf: "opentype",
+  ttf: "truetype",
+  eot: "embedded-opentype"
+};
 const SYSTEM_METRICS = {
   "Times New Roman": {
     ascent: 1825,
@@ -84,6 +91,7 @@ export {
   DEFAULTS,
   DEFAULT_FALLBACKS,
   FONTS_TYPES_FILE,
+  FONT_FORMAT_MAP,
   FONT_TYPES,
   LOCAL_PROVIDER_NAME,
   RESOLVED_VIRTUAL_MODULE_ID,

package/dist/assets/fonts/load.js

@@ -28,18 +28,24 @@ async function loadFonts({
   for (const family of families) {
     const preloadData = [];
     let css = "";
-    let fallbackFontData = null;
-    const collect = ({ hash, type, value }) => {
+    const fallbacks = family.fallbacks ?? DEFAULTS.fallbacks;
+    const fallbackFontData = [];
+    const collect = ({ hash, type, value, data }, collectPreload) => {
       const url = base + hash;
       if (!hashToUrlMap.has(hash)) {
         hashToUrlMap.set(hash, value);
-        preloadData.push({ url, type });
+        if (collectPreload) {
+          preloadData.push({ url, type });
+        }
       }
-      if (family.fallbacks && family.fallbacks.length > 0) {
-        fallbackFontData ??= {
+      if (fallbacks && fallbacks.length > 0 && // If the same data has already been sent for this family, we don't want to have duplicate fallbacks
+      // Such scenario can occur with unicode ranges
+      !fallbackFontData.some((f) => JSON.stringify(f.data) === JSON.stringify(data))) {
+        fallbackFontData.push({
           hash,
-          url: value
-        };
+          url: value,
+          data
+        });
       }
       return url;
     };
@@ -47,7 +53,7 @@ async function loadFonts({
     if (family.provider === LOCAL_PROVIDER_NAME) {
       const result = resolveLocalFont({
         family,
-        proxyURL: (value) => {
+        proxyURL: ({ value, data }) => {
           return proxyURL({
             value,
             // We hash based on the filepath and the contents, since the user could replace
@@ -61,7 +67,7 @@ async function loadFonts({
               }
               return hashString(v + content);
             },
-            collect
+            collect: (input) => collect({ ...input, data }, true)
           });
         }
       });
@@ -83,21 +89,40 @@ async function loadFonts({
       );
       fonts = result.fonts.filter(
         (font) => typeof font.meta?.priority === "number" ? font.meta.priority === 0 : true
-      ).map((font) => ({
-        ...font,
-        src: font.src.slice(0, 1).map(
-          (source) => "name" in source ? source : {
-            ...source,
-            originalURL: source.url,
-            url: proxyURL({
-              value: source.url,
-              // We only use the url for hashing since the service returns urls with a hash already
-              hashString,
-              collect
-            })
-          }
-        )
-      }));
+      ).map((font) => {
+        let index = 0;
+        return {
+          ...font,
+          src: font.src.map((source) => {
+            if ("name" in source) {
+              return source;
+            }
+            const proxied = {
+              ...source,
+              originalURL: source.url,
+              url: proxyURL({
+                value: source.url,
+                // We only use the url for hashing since the service returns urls with a hash already
+                hashString,
+                // We only collect the first URL to avoid preloading fallback sources (eg. we only
+                // preload woff2 if woff is available)
+                collect: (data) => collect(
+                  {
+                    ...data,
+                    data: {
+                      weight: font.weight,
+                      style: font.style
+                    }
+                  },
+                  index === 0
+                )
+              })
+            };
+            index++;
+            return proxied;
+          })
+        };
+      });
     }
     for (const data of fonts) {
       css += generateFontFace(family.nameWithHash, {
@@ -114,7 +139,7 @@ async function loadFonts({
     const fallbackData = await generateFallbacksCSS({
       family,
       font: fallbackFontData,
-      fallbacks: family.fallbacks ?? DEFAULTS.fallbacks,
+      fallbacks,
       metrics: family.optimizedFallbacks ?? DEFAULTS.optimizedFallbacks ? {
         getMetricsForFamily,
         generateFontFace: generateFallbackFontFace
@@ -122,7 +147,9 @@ async function loadFonts({
     });
     const cssVarValues = [family.nameWithHash];
     if (fallbackData) {
-      css += fallbackData.css;
+      if (fallbackData.css) {
+        css += fallbackData.css;
+      }
       cssVarValues.push(...fallbackData.fallbacks);
     }
     css += `:root { ${family.cssVariable}: ${cssVarValues.join(", ")}; }`;

package/dist/assets/fonts/metrics.d.ts

@@ -6,5 +6,5 @@ export declare function generateFallbackFontFace({ metrics, fallbackMetrics, nam
     fallbackMetrics: FontFaceMetrics;
     name: string;
     font: string;
-    properties?: Record<string, string | undefined>;
+    properties: Record<string, string | undefined>;
 }): string;

package/dist/assets/fonts/metrics.js

@@ -30,7 +30,7 @@ function generateFallbackFontFace({
   fallbackMetrics,
   name: fallbackName,
   font: fallbackFontName,
-  properties = {}
+  properties
 }) {
   const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
   const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;

package/dist/assets/fonts/providers/local.d.ts

@@ -4,7 +4,10 @@ type InitializedProvider = NonNullable<Awaited<ReturnType<unifont.Provider>>>;
 type ResolveFontResult = NonNullable<Awaited<ReturnType<InitializedProvider['resolveFont']>>>;
 interface Options {
     family: ResolvedLocalFontFamily;
-    proxyURL: (value: string) => string;
+    proxyURL: (params: {
+        value: string;
+        data: Partial<unifont.FontFaceData>;
+    }) => string;
 }
 export declare function resolveLocalFont({ family, proxyURL }: Options): ResolveFontResult;
 export {};

package/dist/assets/fonts/providers/local.js

@@ -1,3 +1,4 @@
+import { FONT_FORMAT_MAP } from "../constants.js";
 import { extractFontType } from "../utils.js";
 function resolveLocalFont({ family, proxyURL }) {
   const fonts = [];
@@ -8,8 +9,14 @@ function resolveLocalFont({ family, proxyURL }) {
       src: variant.src.map(({ url: originalURL, tech }) => {
         return {
           originalURL,
-          url: proxyURL(originalURL),
-          format: extractFontType(originalURL),
+          url: proxyURL({
+            value: originalURL,
+            data: {
+              weight: variant.weight,
+              style: variant.style
+            }
+          }),
+          format: FONT_FORMAT_MAP[extractFontType(originalURL)],
           tech
         };
       })

package/dist/assets/fonts/utils.d.ts

@@ -6,6 +6,7 @@ import { type ResolveProviderOptions } from './providers/utils.js';
 import type { FontFamily, FontType, ResolvedFontFamily } from './types.js';
 export declare function toCSS(properties: Record<string, string | undefined>, indent?: number): string;
 export declare function renderFontFace(properties: Record<string, string | undefined>): string;
+export declare function unifontFontFaceDataToProperties(font: Partial<unifont.FontFaceData>): Record<string, string | undefined>;
 export declare function generateFontFace(family: string, font: unifont.FontFaceData): string;
 export declare function renderFontSrc(sources: Exclude<unifont.FontFaceData['src'][number], string>[]): string;
 export declare function withoutQuotes(str: string): string;
@@ -46,6 +47,7 @@ export declare function isGenericFontFamily(str: string): str is keyof typeof DE
 export type GetMetricsForFamilyFont = {
     hash: string;
     url: string;
+    data: Partial<unifont.FontFaceData>;
 };
 export type GetMetricsForFamily = (name: string, 
 /** A remote url or local filepath to a font file. Used if metrics can't be resolved purely from the family name */
@@ -61,13 +63,13 @@ export declare function generateFallbacksCSS({ family, fallbacks: _fallbacks, fo
     family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
     /** The family fallbacks */
     fallbacks: Array<string>;
-    font: GetMetricsForFamilyFont | null;
+    font: Array<GetMetricsForFamilyFont>;
     metrics: {
         getMetricsForFamily: GetMetricsForFamily;
         generateFontFace: typeof generateFallbackFontFace;
     } | null;
 }): Promise<null | {
-    css: string;
+    css?: string;
     fallbacks: Array<string>;
 }>;
 /**

package/dist/assets/fonts/utils.js

@@ -13,10 +13,9 @@ function renderFontFace(properties) {
 }
 `;
 }
-function generateFontFace(family, font) {
-  return renderFontFace({
-    "font-family": family,
-    src: renderFontSrc(font.src),
+function unifontFontFaceDataToProperties(font) {
+  return {
+    src: font.src ? renderFontSrc(font.src) : void 0,
     "font-display": font.display ?? "swap",
     "unicode-range": font.unicodeRange?.join(","),
     "font-weight": Array.isArray(font.weight) ? font.weight.join(" ") : font.weight?.toString(),
@@ -24,17 +23,23 @@ function generateFontFace(family, font) {
     "font-stretch": font.stretch,
     "font-feature-settings": font.featureSettings,
     "font-variation-settings": font.variationSettings
+  };
+}
+function generateFontFace(family, font) {
+  return renderFontFace({
+    "font-family": family,
+    ...unifontFontFaceDataToProperties(font)
   });
 }
 function renderFontSrc(sources) {
   return sources.map((src) => {
     if ("url" in src) {
       let rendered = `url("${src.url}")`;
-      for (const key of ["format", "tech"]) {
-        const value = src[key];
-        if (value) {
-          rendered += ` ${key}(${value})`;
-        }
+      if (src.format) {
+        rendered += ` format("${src.format}")`;
+      }
+      if (src.tech) {
+        rendered += ` tech(${src.tech})`;
       }
       return rendered;
     }
@@ -91,35 +96,39 @@ async function generateFallbacksCSS({
   if (fallbacks.length === 0) {
     return null;
   }
-  let css = "";
-  if (!fontData || !metrics) {
-    return { css, fallbacks };
+  if (fontData.length === 0 || !metrics) {
+    return { fallbacks };
   }
   const lastFallback = fallbacks[fallbacks.length - 1];
   if (!isGenericFontFamily(lastFallback)) {
-    return { css, fallbacks };
+    return { fallbacks };
   }
   const localFonts = DEFAULT_FALLBACKS[lastFallback];
   if (localFonts.length === 0) {
-    return { css, fallbacks };
+    return { fallbacks };
   }
-  const foundMetrics = await metrics.getMetricsForFamily(family.name, fontData);
-  if (!foundMetrics) {
-    return { css, fallbacks };
+  if (localFonts.includes(
+    // @ts-expect-error TS is not smart enough
+    family.name
+  )) {
+    return { fallbacks };
   }
   const localFontsMappings = localFonts.map((font) => ({
     font,
     name: `"${family.nameWithHash} fallback: ${font}"`
   }));
   fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
+  let css = "";
   for (const { font, name } of localFontsMappings) {
-    css += metrics.generateFontFace({
-      metrics: foundMetrics,
-      fallbackMetrics: SYSTEM_METRICS[font],
-      font,
-      name
-      // TODO: forward some properties once we generate one fallback per font face data
-    });
+    for (const { hash, url, data } of fontData) {
+      css += metrics.generateFontFace({
+        metrics: await metrics.getMetricsForFamily(family.name, { hash, url, data }),
+        fallbackMetrics: SYSTEM_METRICS[font],
+        font,
+        name,
+        properties: unifontFontFaceDataToProperties(data)
+      });
+    }
   }
   return { css, fallbacks };
 }
@@ -200,13 +209,12 @@ function familiesToUnifontProviders({
         })
       )
     );
-    if (hashes.has(hash)) {
-      continue;
-    }
     unifontProvider._name += `-${hash}`;
     provider.name = unifontProvider._name;
-    hashes.add(hash);
-    providers.push(unifontProvider);
+    if (!hashes.has(hash)) {
+      hashes.add(hash);
+      providers.push(unifontProvider);
+    }
   }
   return { families, providers };
 }
@@ -233,5 +241,6 @@ export {
   resolveFontFamily,
   sortObjectByKey,
   toCSS,
+  unifontFontFaceDataToProperties,
   withoutQuotes
 };

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.7.2") {
+    if (previousAstroVersion && previousAstroVersion !== "5.7.4") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.7.2") {
-      await this.#store.metaStore().set("astro-version", "5.7.2");
+    if ("5.7.4") {
+      await this.#store.metaStore().set("astro-version", "5.7.4");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.7.2";
+const ASTRO_VERSION = "5.7.4";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.7.2";
+  const currentVersion = "5.7.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.7.2";
+  const version = "5.7.4";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -282,7 +282,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"5.7.2"}`
+        `v${"5.7.4"}`
       )} ${headline}`
     );
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.7.2",
+  "version": "5.7.4",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -160,9 +160,9 @@
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.5",
     "zod-to-ts": "^1.2.0",
-    "@astrojs/internal-helpers": "0.6.1",
+    "@astrojs/markdown-remark": "6.3.1",
     "@astrojs/telemetry": "3.2.0",
-    "@astrojs/markdown-remark": "6.3.1"
+    "@astrojs/internal-helpers": "0.6.1"
   },
   "optionalDependencies": {
     "sharp": "^0.33.3"