astro 5.7.10 → 5.7.12

package/components/ClientRouter.astro

@@ -37,6 +37,7 @@ const { fallback = 'animate' } = Astro.props;
 	import { init } from 'astro/virtual-modules/prefetch.js';
 
 	type Fallback = 'none' | 'animate' | 'swap';
+	let lastClickedElementLeavingWindow: EventTarget | null = null;
 
 	function getFallback(): Fallback {
 		const el = document.querySelector('[name="astro-view-transitions-fallback"]');
@@ -50,6 +51,13 @@ const { fallback = 'animate' } = Astro.props;
 		return el.dataset.astroReload !== undefined;
 	}
 
+	const leavesWindow = (ev: MouseEvent) =>
+		(ev.button && ev.button !== 0) || // left clicks only
+		ev.metaKey || // new tab (mac)
+		ev.ctrlKey || // new tab (windows)
+		ev.altKey || // download
+		ev.shiftKey; // new window
+
 	if (supportsViewTransitions || getFallback() !== 'none') {
 		if (import.meta.env.DEV && window.matchMedia('(prefers-reduced-motion)').matches) {
 			console.warn(
@@ -58,6 +66,9 @@ const { fallback = 'animate' } = Astro.props;
 		}
 		document.addEventListener('click', (ev) => {
 			let link = ev.target;
+
+			lastClickedElementLeavingWindow = leavesWindow(ev) ? link : null;
+
 			if (ev.composed) {
 				link = ev.composedPath()[0];
 			}
@@ -82,11 +93,7 @@ const { fallback = 'animate' } = Astro.props;
 				!link.href ||
 				(linkTarget && linkTarget !== '_self') ||
 				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
+				lastClickedElementLeavingWindow ||
 				ev.defaultPrevented
 			) {
 				// No page transitions in these cases,
@@ -102,11 +109,15 @@ const { fallback = 'animate' } = Astro.props;
 
 		document.addEventListener('submit', (ev) => {
 			let el = ev.target as HTMLElement;
-			if (el.tagName !== 'FORM' || ev.defaultPrevented || isReloadEl(el)) {
+			const submitter = ev.submitter;
+
+			const clickedWithKeys = submitter && submitter === lastClickedElementLeavingWindow;
+			lastClickedElementLeavingWindow = null;
+
+			if (el.tagName !== 'FORM' || ev.defaultPrevented || isReloadEl(el) || clickedWithKeys) {
 				return;
 			}
 			const form = el as HTMLFormElement;
-			const submitter = ev.submitter;
 			const formData = new FormData(form, submitter);
 			// form.action and form.method can point to an <input name="action"> or <input name="method">
 			// in which case should fallback to the form attribute

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const styleSchema: z.ZodEnum<["normal", "italic", "oblique"]>;
 export declare const fontProviderSchema: z.ZodObject<{
     /**
      * URL, path relative to the root or package import.
@@ -66,21 +67,17 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
          * weight: "100 900"
          * ```
          */
-        weight: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        weight: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         /**
          * A [font style](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style).
          */
-        style: z.ZodEnum<["normal", "italic", "oblique"]>;
+        style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
         /**
          * @default `"swap"`
          *
          * A [font display](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display).
          */
         display: z.ZodOptional<z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>>;
-        /**
-         * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
-         */
-        unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
         /**
          * A [font stretch](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-stretch).
          */
@@ -107,8 +104,11 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         }>]>, "atleastone">;
+        /**
+         * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
+         */
+        unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
     }>, "strict", z.ZodTypeAny, {
-        style: "normal" | "italic" | "oblique";
         src: [string | URL | {
             url: string | URL;
             tech?: string | undefined;
@@ -116,14 +116,14 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         })[]];
-        weight: string | number;
+        style?: "normal" | "italic" | "oblique" | undefined;
+        weight?: string | number | undefined;
         display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
+        unicodeRange?: [string, ...string[]] | undefined;
     }, {
-        style: "normal" | "italic" | "oblique";
         src: [string | URL | {
             url: string | URL;
             tech?: string | undefined;
@@ -131,19 +131,19 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         })[]];
-        weight: string | number;
+        style?: "normal" | "italic" | "oblique" | undefined;
+        weight?: string | number | undefined;
         display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
+        unicodeRange?: [string, ...string[]] | undefined;
     }>, "atleastone">;
 }>, "strict", z.ZodTypeAny, {
     name: string;
     cssVariable: string;
     provider: "local";
     variants: [{
-        style: "normal" | "italic" | "oblique";
         src: [string | URL | {
             url: string | URL;
             tech?: string | undefined;
@@ -151,14 +151,14 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         })[]];
-        weight: string | number;
+        style?: "normal" | "italic" | "oblique" | undefined;
+        weight?: string | number | undefined;
         display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
+        unicodeRange?: [string, ...string[]] | undefined;
     }, ...{
-        style: "normal" | "italic" | "oblique";
         src: [string | URL | {
             url: string | URL;
             tech?: string | undefined;
@@ -166,12 +166,13 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         })[]];
-        weight: string | number;
+        style?: "normal" | "italic" | "oblique" | undefined;
+        weight?: string | number | undefined;
         display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
+        unicodeRange?: [string, ...string[]] | undefined;
     }[]];
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
@@ -180,7 +181,6 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
     cssVariable: string;
     provider: "local";
     variants: [{
-        style: "normal" | "italic" | "oblique";
         src: [string | URL | {
             url: string | URL;
             tech?: string | undefined;
@@ -188,14 +188,14 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         })[]];
-        weight: string | number;
+        style?: "normal" | "italic" | "oblique" | undefined;
+        weight?: string | number | undefined;
         display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
+        unicodeRange?: [string, ...string[]] | undefined;
     }, ...{
-        style: "normal" | "italic" | "oblique";
         src: [string | URL | {
             url: string | URL;
             tech?: string | undefined;
@@ -203,12 +203,13 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
             url: string | URL;
             tech?: string | undefined;
         })[]];
-        weight: string | number;
+        style?: "normal" | "italic" | "oblique" | undefined;
+        weight?: string | number | undefined;
         display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
+        unicodeRange?: [string, ...string[]] | undefined;
     }[]];
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
@@ -230,21 +231,17 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
      * weight: "100 900"
      * ```
      */
-    weight: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    weight: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     /**
      * A [font style](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style).
      */
-    style: z.ZodEnum<["normal", "italic", "oblique"]>;
+    style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
     /**
      * @default `"swap"`
      *
      * A [font display](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display).
      */
     display: z.ZodOptional<z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>>;
-    /**
-     * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
-     */
-    unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
     /**
      * A [font stretch](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-stretch).
      */
@@ -325,6 +322,10 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
      * An array of [font subsets](https://knaap.dev/posts/font-subsetting/):
      */
     subsets: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
+    /**
+     * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
+     */
+    unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
 }>, "strict", z.ZodTypeAny, {
     name: string;
     cssVariable: string;
@@ -335,10 +336,10 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
     display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-    unicodeRange?: [string, ...string[]] | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
     variationSettings?: string | undefined;
+    unicodeRange?: [string, ...string[]] | undefined;
     weights?: [string | number, ...(string | number)[]] | undefined;
     styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
     subsets?: [string, ...string[]] | undefined;
@@ -352,10 +353,10 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
     display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
-    unicodeRange?: [string, ...string[]] | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
     variationSettings?: string | undefined;
+    unicodeRange?: [string, ...string[]] | undefined;
     weights?: [string | number, ...(string | number)[]] | undefined;
     styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
     subsets?: [string, ...string[]] | undefined;

package/dist/assets/fonts/config.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { LOCAL_PROVIDER_NAME } from "./constants.js";
 const weightSchema = z.union([z.string(), z.number()]);
 const styleSchema = z.enum(["normal", "italic", "oblique"]);
+const unicodeRangeSchema = z.array(z.string()).nonempty();
 const familyPropertiesSchema = z.object({
   /**
    * A [font weight](https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight). If the associated font is a [variable font](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_fonts/Variable_fonts_guide), you can specify a range of weights:
@@ -10,21 +11,17 @@ const familyPropertiesSchema = z.object({
    * weight: "100 900"
    * ```
    */
-  weight: weightSchema,
+  weight: weightSchema.optional(),
   /**
    * A [font style](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style).
    */
-  style: styleSchema,
+  style: styleSchema.optional(),
   /**
    * @default `"swap"`
    *
    * A [font display](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display).
    */
   display: z.enum(["auto", "block", "swap", "fallback", "optional"]).optional(),
-  /**
-   * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
-   */
-  unicodeRange: z.array(z.string()).nonempty().optional(),
   /**
    * A [font stretch](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-stretch).
    */
@@ -106,7 +103,11 @@ const localFontFamilySchema = requiredFamilyAttributesSchema.merge(fallbacksSche
               entrypointSchema,
               z.object({ url: entrypointSchema, tech: z.string().optional() }).strict()
             ])
-          ).nonempty()
+          ).nonempty(),
+          /**
+           * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
+           */
+          unicodeRange: unicodeRangeSchema.optional()
           // TODO: find a way to support subsets (through fontkit?)
         }).strict()
       )
@@ -145,11 +146,16 @@ const remoteFontFamilySchema = requiredFamilyAttributesSchema.merge(
      *
      * An array of [font subsets](https://knaap.dev/posts/font-subsetting/):
      */
-    subsets: z.array(z.string()).nonempty().optional()
+    subsets: z.array(z.string()).nonempty().optional(),
+    /**
+     * A [unicode range](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range).
+     */
+    unicodeRange: unicodeRangeSchema.optional()
   })
 ).strict();
 export {
   fontProviderSchema,
   localFontFamilySchema,
-  remoteFontFamilySchema
+  remoteFontFamilySchema,
+  styleSchema
 };

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

@@ -1,4 +1,4 @@
-import type { Defaults } from './types.js';
+import type { Defaults, FontType } from './types.js';
 export declare const LOCAL_PROVIDER_NAME = "local";
 export declare const DEFAULTS: Defaults;
 export declare const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
@@ -6,6 +6,9 @@ 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 FONT_FORMATS: Array<{
+    type: FontType;
+    format: string;
+}>;
 export declare const GENERIC_FALLBACK_NAMES: readonly ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "emoji", "math", "fangsong"];
 export declare const FONTS_TYPES_FILE = "fonts.d.ts";

package/dist/assets/fonts/constants.js

@@ -12,13 +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 FONT_FORMATS = [
+  { type: "woff2", format: "woff2" },
+  { type: "woff", format: "woff" },
+  { type: "otf", format: "opentype" },
+  { type: "ttf", format: "truetype" },
+  { type: "eot", format: "embedded-opentype" }
+];
 const GENERIC_FALLBACK_NAMES = [
   "serif",
   "sans-serif",
@@ -39,7 +39,7 @@ export {
   CACHE_DIR,
   DEFAULTS,
   FONTS_TYPES_FILE,
-  FONT_FORMAT_MAP,
+  FONT_FORMATS,
   FONT_TYPES,
   GENERIC_FALLBACK_NAMES,
   LOCAL_PROVIDER_NAME,

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

@@ -1,6 +1,6 @@
 import type * as unifont from 'unifont';
 import type { CollectedFontForMetrics } from './logic/optimize-fallbacks.js';
-import type { AstroFontProvider, FontFileData, FontType, PreloadData, ResolvedFontProvider } from './types.js';
+import type { AstroFontProvider, FontFileData, FontType, PreloadData, ResolvedFontProvider, Style } from './types.js';
 import type { FontFaceMetrics, GenericFallbackName } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
@@ -26,12 +26,16 @@ export type ErrorHandlerInput = SingleErrorInput<'cannot-load-font-provider', {
     url: string;
 }> | SingleErrorInput<'cannot-extract-font-type', {
     url: string;
+}> | SingleErrorInput<'cannot-extract-data', {
+    family: string;
+    url: string;
 }>;
 export interface ErrorHandler {
     handle: (input: ErrorHandlerInput) => Error;
 }
 export interface UrlProxy {
     proxy: (input: Pick<FontFileData, 'url' | 'init'> & {
+        type: FontType;
         collectPreload: boolean;
         data: Partial<unifont.FontFaceData>;
     }) => string;
@@ -70,4 +74,13 @@ export interface FontFetcher {
 export interface FontTypeExtractor {
     extract: (url: string) => FontType;
 }
+export interface FontFileReader {
+    extract: (input: {
+        family: string;
+        url: string;
+    }) => {
+        weight: string;
+        style: Style;
+    };
+}
 export {};

package/dist/assets/fonts/implementations/error-handler.js

@@ -17,6 +17,14 @@ function getProps(input) {
       ...AstroErrorData.CannotExtractFontType,
       message: AstroErrorData.CannotExtractFontType.message(input.data.url)
     };
+  } else if (input.type === "cannot-extract-data") {
+    return {
+      ...AstroErrorData.CannotDetermineWeightAndStyleFromFontFile,
+      message: AstroErrorData.CannotDetermineWeightAndStyleFromFontFile.message(
+        input.data.family,
+        input.data.url
+      )
+    };
   }
   input;
   return AstroErrorData.UnknownError;

package/dist/assets/fonts/implementations/font-file-reader.d.ts

@@ -0,0 +1,4 @@
+import type { ErrorHandler, FontFileReader } from '../definitions.js';
+export declare function createFontaceFontFileReader({ errorHandler, }: {
+    errorHandler: ErrorHandler;
+}): FontFileReader;

package/dist/assets/fonts/implementations/font-file-reader.js

@@ -0,0 +1,26 @@
+import { readFileSync } from "node:fs";
+import { fontace } from "fontace";
+function createFontaceFontFileReader({
+  errorHandler
+}) {
+  return {
+    extract({ family, url }) {
+      try {
+        const data = fontace(readFileSync(url));
+        return {
+          weight: data.weight,
+          style: data.style
+        };
+      } catch (cause) {
+        throw errorHandler.handle({
+          type: "cannot-extract-data",
+          data: { family, url },
+          cause
+        });
+      }
+    }
+  };
+}
+export {
+  createFontaceFontFileReader
+};

package/dist/assets/fonts/implementations/font-metrics-resolver.js

@@ -45,12 +45,12 @@ function createCapsizeFontMetricsResolver({
       const descentOverride = Math.abs(metrics.descent) / adjustedEmSquare;
       const lineGapOverride = metrics.lineGap / adjustedEmSquare;
       return cssRenderer.generateFontFace(fallbackName, {
+        ...properties,
         src: renderFontSrc([{ name: fallbackFontName }]),
         "size-adjust": toPercentage(sizeAdjust),
         "ascent-override": toPercentage(ascentOverride),
         "descent-override": toPercentage(descentOverride),
-        "line-gap-override": toPercentage(lineGapOverride),
-        ...properties
+        "line-gap-override": toPercentage(lineGapOverride)
       });
     }
   };

package/dist/assets/fonts/implementations/url-proxy.d.ts

@@ -1,8 +1,7 @@
-import type { DataCollector, FontTypeExtractor, Hasher, UrlProxy, UrlProxyContentResolver } from '../definitions.js';
-export declare function createUrlProxy({ base, contentResolver, hasher, dataCollector, fontTypeExtractor, }: {
+import type { DataCollector, Hasher, UrlProxy, UrlProxyContentResolver } from '../definitions.js';
+export declare function createUrlProxy({ base, contentResolver, hasher, dataCollector, }: {
     base: string;
     contentResolver: UrlProxyContentResolver;
     hasher: Hasher;
     dataCollector: DataCollector;
-    fontTypeExtractor: FontTypeExtractor;
 }): UrlProxy;

package/dist/assets/fonts/implementations/url-proxy.js

@@ -2,12 +2,10 @@ function createUrlProxy({
   base,
   contentResolver,
   hasher,
-  dataCollector,
-  fontTypeExtractor
+  dataCollector
 }) {
   return {
-    proxy({ url: originalUrl, data, collectPreload, init }) {
-      const type = fontTypeExtractor.extract(originalUrl);
+    proxy({ url: originalUrl, type, data, collectPreload, init }) {
       const hash = `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
       const url = base + hash;
       dataCollector.collect({

package/dist/assets/fonts/logic/normalize-remote-font-faces.d.ts

@@ -1,6 +1,7 @@
 import type * as unifont from 'unifont';
-import type { UrlProxy } from '../definitions.js';
-export declare function normalizeRemoteFontFaces({ fonts, urlProxy, }: {
+import type { FontTypeExtractor, UrlProxy } from '../definitions.js';
+export declare function normalizeRemoteFontFaces({ fonts, urlProxy, fontTypeExtractor, }: {
     fonts: Array<unifont.FontFaceData>;
     urlProxy: UrlProxy;
+    fontTypeExtractor: FontTypeExtractor;
 }): Array<unifont.FontFaceData>;

package/dist/assets/fonts/logic/normalize-remote-font-faces.js

@@ -1,6 +1,8 @@
+import { FONT_FORMATS } from "../constants.js";
 function normalizeRemoteFontFaces({
   fonts,
-  urlProxy
+  urlProxy,
+  fontTypeExtractor
 }) {
   return fonts.filter((font) => typeof font.meta?.priority === "number" ? font.meta.priority === 0 : true).map((font) => {
     let index = 0;
@@ -10,11 +12,13 @@ function normalizeRemoteFontFaces({
         if ("name" in source) {
           return source;
         }
+        const url = source.url.startsWith("//") ? `https:${source.url}` : source.url;
         const proxied = {
           ...source,
-          originalURL: source.url,
+          originalURL: url,
           url: urlProxy.proxy({
-            url: source.url,
+            url,
+            type: FONT_FORMATS.find((e) => e.format === source.format)?.type ?? fontTypeExtractor.extract(source.url),
             // We only collect the first URL to avoid preloading fallback sources (eg. we only
             // preload woff2 if woff is available)
             collectPreload: index === 0,

package/dist/assets/fonts/logic/resolve-families.js

@@ -6,7 +6,7 @@ function resolveVariants({
 }) {
   return variants.map((variant) => ({
     ...variant,
-    weight: variant.weight.toString(),
+    weight: variant.weight?.toString(),
     src: variant.src.map((value) => {
       const isValue = typeof value === "string" || value instanceof URL;
       const url = (isValue ? value : value.url).toString();

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

@@ -1,5 +1,6 @@
 import type { Storage } from 'unstorage';
-import type { CssRenderer, FontMetricsResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, SystemFallbacksProvider, UrlProxy } from './definitions.js';
+import type { Logger } from '../../core/logger/core.js';
+import type { CssRenderer, FontFileReader, FontMetricsResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, SystemFallbacksProvider, UrlProxy } from './definitions.js';
 import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap } from './types.js';
 /**
  * Manages how fonts are resolved:
@@ -19,7 +20,7 @@ import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFil
  *
  * Once that's done, the collected data is returned
  */
-export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, storage, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, createUrlProxy, defaults, }: {
+export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, storage, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, }: {
     families: Array<FontFamily>;
     hasher: Hasher;
     remoteFontProviderResolver: RemoteFontProviderResolver;
@@ -29,6 +30,8 @@ export declare function orchestrate({ families, hasher, remoteFontProviderResolv
     systemFallbacksProvider: SystemFallbacksProvider;
     fontMetricsResolver: FontMetricsResolver;
     fontTypeExtractor: FontTypeExtractor;
+    fontFileReader: FontFileReader;
+    logger: Logger;
     createUrlProxy: (params: CreateUrlProxyParams) => UrlProxy;
     defaults: Defaults;
 }): Promise<{

package/dist/assets/fonts/orchestrate.js

@@ -1,3 +1,4 @@
+import { bold } from "kleur/colors";
 import * as unifont from "unifont";
 import { LOCAL_PROVIDER_NAME } from "./constants.js";
 import { extractUnifontProviders } from "./logic/extract-unifont-providers.js";
@@ -16,6 +17,8 @@ async function orchestrate({
   systemFallbacksProvider,
   fontMetricsResolver,
   fontTypeExtractor,
+  fontFileReader,
+  logger,
   createUrlProxy,
   defaults
 }) {
@@ -63,7 +66,8 @@ async function orchestrate({
       const result = resolveLocalFont({
         family,
         urlProxy,
-        fontTypeExtractor
+        fontTypeExtractor,
+        fontFileReader
       });
       fonts = result.fonts;
     } else {
@@ -81,7 +85,13 @@ async function orchestrate({
         // from families (inside extractUnifontProviders).
         [family.provider.name]
       );
-      fonts = normalizeRemoteFontFaces({ fonts: result.fonts, urlProxy });
+      if (result.fonts.length === 0) {
+        logger.warn(
+          "assets",
+          `No data found for font family ${bold(family.name)}. Review your configuration`
+        );
+      }
+      fonts = normalizeRemoteFontFaces({ fonts: result.fonts, urlProxy, fontTypeExtractor });
     }
     for (const data of fonts) {
       css += cssRenderer.generateFontFace(

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

@@ -1,12 +1,13 @@
 import type * as unifont from 'unifont';
-import type { FontTypeExtractor, UrlProxy } from '../definitions.js';
+import type { FontFileReader, FontTypeExtractor, UrlProxy } from '../definitions.js';
 import type { ResolvedLocalFontFamily } from '../types.js';
 interface Options {
     family: ResolvedLocalFontFamily;
     urlProxy: UrlProxy;
     fontTypeExtractor: FontTypeExtractor;
+    fontFileReader: FontFileReader;
 }
-export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor }: Options): {
+export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor, fontFileReader, }: Options): {
     fonts: Array<unifont.FontFaceData>;
 };
 export {};