astro 5.7.1 → 5.7.3

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

@@ -11,5 +11,71 @@ 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 DEFAULT_FALLBACKS: Record<string, Array<string>>;
+export declare const FONT_FORMAT_MAP: Record<(typeof FONT_TYPES)[number], string>;
+export declare const SYSTEM_METRICS: {
+    'Times New Roman': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    Arial: {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    'Courier New': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    BlinkMacSystemFont: {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    'Segoe UI': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    Roboto: {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    'Helvetica Neue': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+};
+export declare const DEFAULT_FALLBACKS: {
+    readonly serif: ["Times New Roman"];
+    readonly 'sans-serif': ["Arial"];
+    readonly monospace: ["Courier New"];
+    readonly cursive: [];
+    readonly fantasy: [];
+    readonly 'system-ui': ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"];
+    readonly 'ui-serif': ["Times New Roman"];
+    readonly 'ui-sans-serif': ["Arial"];
+    readonly 'ui-monospace': ["Courier New"];
+    readonly 'ui-rounded': [];
+    readonly emoji: [];
+    readonly math: [];
+    readonly fangsong: [];
+};
 export declare const FONTS_TYPES_FILE = "fonts.d.ts";

package/dist/assets/fonts/constants.js

@@ -12,6 +12,64 @@ 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,
+    descent: -443,
+    lineGap: 87,
+    unitsPerEm: 2048,
+    xWidthAvg: 832
+  },
+  Arial: {
+    ascent: 1854,
+    descent: -434,
+    lineGap: 67,
+    unitsPerEm: 2048,
+    xWidthAvg: 913
+  },
+  "Courier New": {
+    ascent: 1705,
+    descent: -615,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 1229
+  },
+  BlinkMacSystemFont: {
+    ascent: 1980,
+    descent: -432,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 853
+  },
+  "Segoe UI": {
+    ascent: 2210,
+    descent: -514,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 908
+  },
+  Roboto: {
+    ascent: 1900,
+    descent: -500,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 911
+  },
+  "Helvetica Neue": {
+    ascent: 952,
+    descent: -213,
+    lineGap: 28,
+    unitsPerEm: 1e3,
+    xWidthAvg: 450
+  }
+};
 const DEFAULT_FALLBACKS = {
   serif: ["Times New Roman"],
   "sans-serif": ["Arial"],
@@ -33,9 +91,11 @@ export {
   DEFAULTS,
   DEFAULT_FALLBACKS,
   FONTS_TYPES_FILE,
+  FONT_FORMAT_MAP,
   FONT_TYPES,
   LOCAL_PROVIDER_NAME,
   RESOLVED_VIRTUAL_MODULE_ID,
+  SYSTEM_METRICS,
   URL_PREFIX,
   VIRTUAL_MODULE_ID
 };

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

@@ -1,9 +1,10 @@
 import { type Font } from '@capsizecss/unpack';
 export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
 export declare function readMetrics(family: string, buffer: Buffer): Promise<FontFaceMetrics>;
-export declare function generateFallbackFontFace(metrics: FontFaceMetrics, fallback: {
+export declare function generateFallbackFontFace({ metrics, fallbackMetrics, name: fallbackName, font: fallbackFontName, properties, }: {
+    metrics: FontFaceMetrics;
+    fallbackMetrics: FontFaceMetrics;
     name: string;
     font: string;
-    metrics?: FontFaceMetrics;
-    [key: string]: any;
+    properties?: Record<string, string | undefined>;
 }): string;

package/dist/assets/fonts/metrics.js

@@ -1,4 +1,5 @@
 import { fromBuffer } from "@capsizecss/unpack";
+import { renderFontFace, renderFontSrc } from "./utils.js";
 const metricCache = {};
 function filterRequiredMetrics({
   ascent,
@@ -24,36 +25,29 @@ function toPercentage(value, fractionDigits = 4) {
   const percentage = value * 100;
   return `${+percentage.toFixed(fractionDigits)}%`;
 }
-function toCSS(properties, indent = 2) {
-  return Object.entries(properties).map(([key, value]) => `${" ".repeat(indent)}${key}: ${value};`).join("\n");
-}
-function generateFallbackFontFace(metrics, fallback) {
-  const {
-    name: fallbackName,
-    font: fallbackFontName,
-    metrics: fallbackMetrics,
-    ...properties
-  } = fallback;
+function generateFallbackFontFace({
+  metrics,
+  fallbackMetrics,
+  name: fallbackName,
+  font: fallbackFontName,
+  properties = {}
+}) {
   const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
-  const fallbackFontXAvgRatio = fallbackMetrics ? fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm : 1;
-  const sizeAdjust = fallbackMetrics && preferredFontXAvgRatio && fallbackFontXAvgRatio ? preferredFontXAvgRatio / fallbackFontXAvgRatio : 1;
+  const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;
+  const sizeAdjust = preferredFontXAvgRatio / fallbackFontXAvgRatio;
   const adjustedEmSquare = metrics.unitsPerEm * sizeAdjust;
   const ascentOverride = metrics.ascent / adjustedEmSquare;
   const descentOverride = Math.abs(metrics.descent) / adjustedEmSquare;
   const lineGapOverride = metrics.lineGap / adjustedEmSquare;
-  const declaration = {
-    "font-family": JSON.stringify(fallbackName),
-    src: `local(${JSON.stringify(fallbackFontName)})`,
+  return renderFontFace({
+    "font-family": fallbackName,
+    src: renderFontSrc([{ name: fallbackFontName }]),
     "size-adjust": toPercentage(sizeAdjust),
     "ascent-override": toPercentage(ascentOverride),
     "descent-override": toPercentage(descentOverride),
     "line-gap-override": toPercentage(lineGapOverride),
     ...properties
-  };
-  return `@font-face {
-${toCSS(declaration)}
-}
-`;
+  });
 }
 export {
   generateFallbackFontFace,

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 = [];
@@ -9,7 +10,7 @@ function resolveLocalFont({ family, proxyURL }) {
         return {
           originalURL,
           url: proxyURL(originalURL),
-          format: extractFontType(originalURL),
+          format: FONT_FORMAT_MAP[extractFontType(originalURL)],
           tech
         };
       })

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

@@ -4,7 +4,11 @@ import { DEFAULT_FALLBACKS } from './constants.js';
 import type { FontFaceMetrics, generateFallbackFontFace } from './metrics.js';
 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 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;
 export declare function extractFontType(str: string): FontType;
 export declare function isFontType(str: string): str is FontType;
 export declare function cache(storage: Storage, key: string, cb: () => Promise<Buffer>): Promise<Buffer>;

package/dist/assets/fonts/utils.js

@@ -2,37 +2,49 @@ import { createRequire } from "node:module";
 import { extname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { DEFAULT_FALLBACKS, FONT_TYPES, LOCAL_PROVIDER_NAME } from "./constants.js";
+import { DEFAULT_FALLBACKS, FONT_TYPES, LOCAL_PROVIDER_NAME, SYSTEM_METRICS } from "./constants.js";
 import { resolveProvider } from "./providers/utils.js";
+function toCSS(properties, indent = 2) {
+  return Object.entries(properties).filter(([, value]) => Boolean(value)).map(([key, value]) => `${" ".repeat(indent)}${key}: ${value};`).join("\n");
+}
+function renderFontFace(properties) {
+  return `@font-face {
+	${toCSS(properties)}
+}
+`;
+}
 function generateFontFace(family, font) {
-  return [
-    "@font-face {",
-    `  font-family: ${family};`,
-    `  src: ${renderFontSrc(font.src)};`,
-    `  font-display: ${font.display ?? "swap"};`,
-    font.unicodeRange && `  unicode-range: ${font.unicodeRange};`,
-    font.weight && `  font-weight: ${Array.isArray(font.weight) ? font.weight.join(" ") : font.weight};`,
-    font.style && `  font-style: ${font.style};`,
-    font.stretch && `  font-stretch: ${font.stretch};`,
-    font.featureSettings && `  font-feature-settings: ${font.featureSettings};`,
-    font.variationSettings && `  font-variation-settings: ${font.variationSettings};`,
-    `}`
-  ].filter(Boolean).join("\n");
+  return renderFontFace({
+    "font-family": family,
+    src: renderFontSrc(font.src),
+    "font-display": font.display ?? "swap",
+    "unicode-range": font.unicodeRange?.join(","),
+    "font-weight": Array.isArray(font.weight) ? font.weight.join(" ") : font.weight?.toString(),
+    "font-style": font.style,
+    "font-stretch": font.stretch,
+    "font-feature-settings": font.featureSettings,
+    "font-variation-settings": font.variationSettings
+  });
 }
 function renderFontSrc(sources) {
   return sources.map((src) => {
     if ("url" in src) {
       let rendered = `url("${src.url}")`;
-      for (const key of ["format", "tech"]) {
-        if (key in src) {
-          rendered += ` ${key}(${src[key]})`;
-        }
+      if (src.format) {
+        rendered += ` format("${src.format}")`;
+      }
+      if (src.tech) {
+        rendered += ` tech(${src.tech})`;
       }
       return rendered;
     }
     return `local("${src.name}")`;
   }).join(", ");
 }
+const QUOTES_RE = /^["']|["']$/g;
+function withoutQuotes(str) {
+  return str.trim().replace(QUOTES_RE, "");
+}
 function extractFontType(str) {
   const extension = extname(str).slice(1);
   if (!isFontType(extension)) {
@@ -101,7 +113,13 @@ async function generateFallbacksCSS({
   }));
   fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
   for (const { font, name } of localFontsMappings) {
-    css += metrics.generateFontFace(foundMetrics, { font, name });
+    css += metrics.generateFontFace({
+      metrics: foundMetrics,
+      fallbackMetrics: SYSTEM_METRICS[font],
+      font,
+      name
+      // TODO: forward some properties once we generate one fallback per font face data
+    });
   }
   return { css, fallbacks };
 }
@@ -182,13 +200,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 };
 }
@@ -209,7 +226,11 @@ export {
   isFontType,
   isGenericFontFamily,
   proxyURL,
+  renderFontFace,
+  renderFontSrc,
   resolveEntrypoint,
   resolveFontFamily,
-  sortObjectByKey
+  sortObjectByKey,
+  toCSS,
+  withoutQuotes
 };

package/dist/assets/fonts/vite-plugin-fonts.js

@@ -18,7 +18,13 @@ import {
 } from "./constants.js";
 import { loadFonts } from "./load.js";
 import { generateFallbackFontFace, readMetrics } from "./metrics.js";
-import { cache, extractFontType, resolveFontFamily, sortObjectByKey } from "./utils.js";
+import {
+  cache,
+  extractFontType,
+  resolveFontFamily,
+  sortObjectByKey,
+  withoutQuotes
+} from "./utils.js";
 async function fetchFont(url) {
   try {
     if (isAbsolute(url)) {
@@ -81,7 +87,7 @@ function fontsPlugin({ settings, sync, logger }) {
           family,
           root: settings.config.root,
           resolveMod,
-          generateNameWithHash: (_family) => `${_family.name}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`
+          generateNameWithHash: (_family) => `${withoutQuotes(_family.name)}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`
         })
       );
     }

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.1") {
+    if (previousAstroVersion && previousAstroVersion !== "5.7.3") {
       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.1") {
-      await this.#store.metaStore().set("astro-version", "5.7.1");
+    if ("5.7.3") {
+      await this.#store.metaStore().set("astro-version", "5.7.3");
     }
     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.1";
+const ASTRO_VERSION = "5.7.3";
 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.1";
+  const currentVersion = "5.7.3";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.7.1";
+  const version = "5.7.3";
   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.1"}`
+        `v${"5.7.3"}`
       )} ${headline}`
     );
   }

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

@@ -236,10 +236,8 @@ function createRedirectRoutes({ settings }, routeMap) {
     } else {
       destination = to.destination;
     }
-    if (!destination.startsWith("/")) {
-      if (!/^https?:\/\//.test(destination) && !URL.canParse(destination)) {
-        throw new AstroError(UnsupportedExternalRedirect);
-      }
+    if (URL.canParse(destination) && !/^https?:\/\//.test(destination)) {
+      throw new AstroError(UnsupportedExternalRedirect);
     }
     routes.push({
       type: "redirect",

package/dist/core/routing/rewrite.js

@@ -39,7 +39,7 @@ function findRouteToRewrite({
   if (!pathname.startsWith("/") && shouldAppendSlash && newUrl.pathname.endsWith("/")) {
     pathname = prependForwardSlash(pathname);
   }
-  if (pathname === "/" && !shouldAppendSlash) {
+  if (pathname === "/" && base !== "/" && !shouldAppendSlash) {
     pathname = "";
   }
   if (base !== "/" && (pathname === "" || pathname === "/") && !shouldAppendSlash) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.7.1",
+  "version": "5.7.3",
   "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/telemetry": "3.2.0",
+    "@astrojs/internal-helpers": "0.6.1",
     "@astrojs/markdown-remark": "6.3.1",
-    "@astrojs/internal-helpers": "0.6.1"
+    "@astrojs/telemetry": "3.2.0"
   },
   "optionalDependencies": {
     "sharp": "^0.33.3"