astro 5.16.13 → 5.16.14

package/components/Font.astro

@@ -4,8 +4,8 @@ import { filterPreloads } from '../dist/assets/fonts/core/filter-preloads.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 
 // TODO: remove check when fonts are stabilized
-const { internalConsumableMap } = mod;
-if (!internalConsumableMap) {
+const { componentDataByCssVariable } = mod;
+if (!componentDataByCssVariable) {
 	throw new AstroError(AstroErrorData.ExperimentalFontsNotEnabled);
 }
 
@@ -17,7 +17,7 @@ interface Props {
 }
 
 const { cssVariable, preload = false } = Astro.props as Props;
-const data = internalConsumableMap.get(cssVariable);
+const data = componentDataByCssVariable.get(cssVariable);
 if (!data) {
 	throw new AstroError({
 		...AstroErrorData.FontFamilyNotFound,
@@ -25,7 +25,7 @@ if (!data) {
 	});
 }
 
-const filteredPreloadData = filterPreloads(data.preloadData, preload);
+const filteredPreloadData = filterPreloads(data.preloads, preload);
 ---
 
 <style set:html={data.css}></style>

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

@@ -2,136 +2,6 @@ import { z } from 'zod';
 export declare const weightSchema: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
 export declare const styleSchema: z.ZodEnum<["normal", "italic", "oblique"]>;
 export declare const displaySchema: z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>;
-export declare const localFontFamilySchema: z.ZodObject<{
-    provider: z.ZodLiteral<"local">;
-    variants: z.ZodArray<z.ZodObject<{
-        src: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>, z.ZodObject<{
-            url: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;
-            tech: z.ZodOptional<z.ZodString>;
-        }, "strict", z.ZodTypeAny, {
-            url: string | URL;
-            tech?: string | undefined;
-        }, {
-            url: string | URL;
-            tech?: string | undefined;
-        }>]>, "atleastone">;
-        weight: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
-        display: z.ZodOptional<z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>>;
-        stretch: z.ZodOptional<z.ZodString>;
-        featureSettings: z.ZodOptional<z.ZodString>;
-        variationSettings: z.ZodOptional<z.ZodString>;
-        unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-    }, "strict", z.ZodTypeAny, {
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }, {
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }>, "atleastone">;
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
-    name: z.ZodString;
-    cssVariable: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    cssVariable: string;
-    provider: "local";
-    variants: [{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }, ...{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }[]];
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-}, {
-    name: string;
-    cssVariable: string;
-    provider: "local";
-    variants: [{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }, ...{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }[]];
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-}>;
 export declare const fontProviderSchema: z.ZodObject<{
     name: z.ZodString;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -167,7 +37,7 @@ export declare const fontProviderSchema: z.ZodObject<{
     init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
     listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
 }>;
-export declare const remoteFontFamilySchema: z.ZodObject<{
+export declare const fontFamilySchema: z.ZodObject<{
     provider: z.ZodObject<{
         name: z.ZodString;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -231,18 +101,18 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
         listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     };
-    options?: Record<string, any> | undefined;
+    weights?: [string | number, ...(string | number)[]] | undefined;
+    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
+    subsets?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
+    optimizedFallbacks?: boolean | undefined;
+    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
     display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
     variationSettings?: string | undefined;
     unicodeRange?: [string, ...string[]] | undefined;
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-    weights?: [string | number, ...(string | number)[]] | undefined;
-    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
-    subsets?: [string, ...string[]] | undefined;
-    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
+    options?: Record<string, any> | undefined;
 }, {
     name: string;
     cssVariable: string;
@@ -257,16 +127,16 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
         listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     };
-    options?: Record<string, any> | undefined;
+    weights?: [string | number, ...(string | number)[]] | undefined;
+    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
+    subsets?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
+    optimizedFallbacks?: boolean | undefined;
+    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
     display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
     variationSettings?: string | undefined;
     unicodeRange?: [string, ...string[]] | undefined;
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-    weights?: [string | number, ...(string | number)[]] | undefined;
-    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
-    subsets?: [string, ...string[]] | undefined;
-    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
+    options?: Record<string, any> | undefined;
 }>;

package/dist/assets/fonts/config.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FONT_TYPES, LOCAL_PROVIDER_NAME } from "./constants.js";
+import { FONT_TYPES } from "./constants.js";
 const weightSchema = z.union([z.string(), z.number()]);
 const styleSchema = z.enum(["normal", "italic", "oblique"]);
 const displaySchema = z.enum(["auto", "block", "swap", "fallback", "optional"]);
@@ -20,24 +20,6 @@ const requiredFamilyAttributesSchema = z.object({
   name: z.string(),
   cssVariable: z.string()
 });
-const entrypointSchema = z.union([z.string(), z.instanceof(URL)]);
-const localFontFamilySchema = z.object({
-  ...requiredFamilyAttributesSchema.shape,
-  ...fallbacksSchema.shape,
-  provider: z.literal(LOCAL_PROVIDER_NAME),
-  variants: z.array(
-    z.object({
-      ...familyPropertiesSchema.shape,
-      src: z.array(
-        z.union([
-          entrypointSchema,
-          z.object({ url: entrypointSchema, tech: z.string().optional() }).strict()
-        ])
-      ).nonempty()
-      // TODO: find a way to support subsets (through fontkit?)
-    }).strict()
-  ).nonempty()
-}).strict();
 const fontProviderSchema = z.object({
   name: z.string(),
   config: z.record(z.string(), z.any()).optional(),
@@ -45,7 +27,7 @@ const fontProviderSchema = z.object({
   resolveFont: z.custom((v) => typeof v === "function"),
   listFonts: z.custom((v) => typeof v === "function").optional()
 }).strict();
-const remoteFontFamilySchema = z.object({
+const fontFamilySchema = z.object({
   ...requiredFamilyAttributesSchema.shape,
   ...fallbacksSchema.shape,
   ...familyPropertiesSchema.omit({
@@ -61,9 +43,8 @@ const remoteFontFamilySchema = z.object({
 }).strict();
 export {
   displaySchema,
+  fontFamilySchema,
   fontProviderSchema,
-  localFontFamilySchema,
-  remoteFontFamilySchema,
   styleSchema,
   weightSchema
 };

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

@@ -1,5 +1,4 @@
 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";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;

package/dist/assets/fonts/constants.js

@@ -1,4 +1,3 @@
-const LOCAL_PROVIDER_NAME = "local";
 const DEFAULTS = {
   weights: ["400"],
   styles: ["normal", "italic"],
@@ -49,7 +48,6 @@ export {
   FONT_FORMATS,
   FONT_TYPES,
   GENERIC_FALLBACK_NAMES,
-  LOCAL_PROVIDER_NAME,
   RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX,
   RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,

package/dist/assets/fonts/core/collect-component-data.d.ts

@@ -0,0 +1,9 @@
+import type { CssRenderer } from '../definitions.js';
+import type { Collaborator, ComponentDataByCssVariable, Defaults, FontFamilyAssets } from '../types.js';
+import type { optimizeFallbacks as _optimizeFallbacks } from './optimize-fallbacks.js';
+export declare function collectComponentData({ fontFamilyAssets, cssRenderer, defaults, optimizeFallbacks, }: {
+    fontFamilyAssets: Array<FontFamilyAssets>;
+    cssRenderer: CssRenderer;
+    defaults: Pick<Defaults, 'fallbacks' | 'optimizedFallbacks'>;
+    optimizeFallbacks: Collaborator<typeof _optimizeFallbacks, 'family' | 'fallbacks' | 'collectedFonts'>;
+}): Promise<ComponentDataByCssVariable>;

package/dist/assets/fonts/core/collect-component-data.js

@@ -0,0 +1,47 @@
+import { unifontFontFaceDataToProperties } from "../utils.js";
+async function collectComponentData({
+  fontFamilyAssets,
+  cssRenderer,
+  defaults,
+  optimizeFallbacks
+}) {
+  const componentDataByCssVariable = /* @__PURE__ */ new Map();
+  for (const { family, fonts, collectedFontsForMetricsByUniqueKey, preloads } of fontFamilyAssets) {
+    let css = "";
+    for (const data of fonts) {
+      css += cssRenderer.generateFontFace(
+        family.uniqueName,
+        unifontFontFaceDataToProperties({
+          src: data.src,
+          weight: data.weight,
+          style: data.style,
+          // User settings override the generated font settings
+          display: data.display ?? family.display,
+          unicodeRange: data.unicodeRange ?? family.unicodeRange,
+          stretch: data.stretch ?? family.stretch,
+          featureSettings: data.featureSettings ?? family.featureSettings,
+          variationSettings: data.variationSettings ?? family.variationSettings
+        })
+      );
+    }
+    const fallbacks = family.fallbacks ?? defaults.fallbacks;
+    const cssVarValues = [family.uniqueName];
+    const optimizeFallbacksResult = family.optimizedFallbacks ?? defaults.optimizedFallbacks ? await optimizeFallbacks({
+      family,
+      fallbacks,
+      collectedFonts: Array.from(collectedFontsForMetricsByUniqueKey.values())
+    }) : null;
+    if (optimizeFallbacksResult) {
+      css += optimizeFallbacksResult.css;
+      cssVarValues.push(...optimizeFallbacksResult.fallbacks);
+    } else {
+      cssVarValues.push(...fallbacks);
+    }
+    css += cssRenderer.generateCssVariable(family.cssVariable, cssVarValues);
+    componentDataByCssVariable.set(family.cssVariable, { preloads, css });
+  }
+  return componentDataByCssVariable;
+}
+export {
+  collectComponentData
+};

package/dist/assets/fonts/core/collect-font-assets-from-faces.d.ts

@@ -0,0 +1,17 @@
+import type * as unifont from 'unifont';
+import type { FontFileIdGenerator, Hasher } from '../definitions.js';
+import type { Defaults, FontFileById, PreloadData, ResolvedFontFamily } from '../types.js';
+import type { CollectedFontForMetrics } from './optimize-fallbacks.js';
+export declare function collectFontAssetsFromFaces({ fonts, fontFileIdGenerator, family, fontFilesIds, collectedFontsIds, hasher, defaults, }: {
+    fonts: Array<unifont.FontFaceData>;
+    fontFileIdGenerator: FontFileIdGenerator;
+    family: Pick<ResolvedFontFamily, 'cssVariable' | 'fallbacks'>;
+    fontFilesIds: Set<string>;
+    collectedFontsIds: Set<string>;
+    hasher: Hasher;
+    defaults: Pick<Defaults, 'fallbacks'>;
+}): {
+    fontFileById: FontFileById;
+    preloads: PreloadData[];
+    collectedFontsForMetricsByUniqueKey: Map<string, CollectedFontForMetrics>;
+};

package/dist/assets/fonts/core/collect-font-assets-from-faces.js

@@ -0,0 +1,71 @@
+import { FONT_FORMATS } from "../constants.js";
+import { renderFontWeight } from "../utils.js";
+function collectFontAssetsFromFaces({
+  fonts,
+  fontFileIdGenerator,
+  family,
+  fontFilesIds,
+  collectedFontsIds,
+  hasher,
+  defaults
+}) {
+  const fontFileById = /* @__PURE__ */ new Map();
+  const collectedFontsForMetricsByUniqueKey = /* @__PURE__ */ new Map();
+  const preloads = [];
+  for (const font of fonts) {
+    let index = 0;
+    for (const source of font.src) {
+      if ("name" in source) {
+        continue;
+      }
+      const format = FONT_FORMATS.find((e) => e.format === source.format);
+      const originalUrl = source.originalURL;
+      const id = fontFileIdGenerator.generate({
+        cssVariable: family.cssVariable,
+        font,
+        originalUrl,
+        type: format.type
+      });
+      if (!fontFilesIds.has(id) && !fontFileById.has(id)) {
+        fontFileById.set(id, { url: originalUrl, init: font.meta?.init });
+        if (index === 0) {
+          preloads.push({
+            style: font.style,
+            subset: font.meta?.subset,
+            type: format.type,
+            url: source.url,
+            weight: renderFontWeight(font.weight)
+          });
+        }
+      }
+      const collected = {
+        id,
+        url: originalUrl,
+        init: font.meta?.init,
+        data: {
+          weight: font.weight,
+          style: font.style,
+          meta: {
+            subset: font.meta?.subset
+          }
+        }
+      };
+      const collectedKey = hasher.hashObject(collected.data);
+      const fallbacks = family.fallbacks ?? defaults.fallbacks;
+      if (fallbacks.length > 0 && // If the same data has already been sent for this family, we don't want to have
+      // duplicated fallbacks. Such scenario can occur with unicode ranges.
+      !collectedFontsIds.has(collectedKey) && !collectedFontsForMetricsByUniqueKey.has(collectedKey)) {
+        collectedFontsForMetricsByUniqueKey.set(collectedKey, collected);
+      }
+      index++;
+    }
+  }
+  return {
+    fontFileById,
+    preloads,
+    collectedFontsForMetricsByUniqueKey
+  };
+}
+export {
+  collectFontAssetsFromFaces
+};

package/dist/assets/fonts/core/collect-font-data.d.ts

@@ -0,0 +1,4 @@
+import type { FontDataByCssVariable, FontFamilyAssets } from '../types.js';
+export declare function collectFontData(fontFamilyAssets: Array<Pick<FontFamilyAssets, 'fonts'> & {
+    family: Pick<FontFamilyAssets['family'], 'cssVariable'>;
+}>): FontDataByCssVariable;

package/dist/assets/fonts/core/collect-font-data.js

@@ -0,0 +1,23 @@
+import { renderFontWeight } from "../utils.js";
+function collectFontData(fontFamilyAssets) {
+  const fontDataByCssVariable = {};
+  for (const { family, fonts } of fontFamilyAssets) {
+    const fontData = [];
+    for (const data of fonts) {
+      fontData.push({
+        weight: renderFontWeight(data.weight),
+        style: data.style,
+        src: data.src.filter((src) => "url" in src).map((src) => ({
+          url: src.url,
+          format: src.format,
+          tech: src.tech
+        }))
+      });
+    }
+    fontDataByCssVariable[family.cssVariable] = fontData;
+  }
+  return fontDataByCssVariable;
+}
+export {
+  collectFontData
+};

package/dist/assets/fonts/core/compute-font-families-assets.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '../../../core/logger/core.js';
+import type { FontResolver, StringMatcher } from '../definitions.js';
+import type { Collaborator, Defaults, FontFileById, ResolvedFontFamily } from '../types.js';
+import type { collectFontAssetsFromFaces as _collectFontAssetsFromFaces } from './collect-font-assets-from-faces.js';
+import type { filterAndTransformFontFaces as _filterAndTransformFontFaces } from './filter-and-transform-font-faces.js';
+import type { getOrCreateFontFamilyAssets as _getOrCreateFontFamilyAssets } from './get-or-create-font-family-assets.js';
+export declare function computeFontFamiliesAssets({ resolvedFamilies, fontResolver, logger, bold, defaults, stringMatcher, getOrCreateFontFamilyAssets, collectFontAssetsFromFaces, filterAndTransformFontFaces, }: {
+    resolvedFamilies: Array<ResolvedFontFamily>;
+    fontResolver: FontResolver;
+    logger: Logger;
+    bold: (input: string) => string;
+    defaults: Defaults;
+    stringMatcher: StringMatcher;
+    getOrCreateFontFamilyAssets: Collaborator<typeof _getOrCreateFontFamilyAssets, 'family' | 'fontFamilyAssetsByUniqueKey'>;
+    filterAndTransformFontFaces: Collaborator<typeof _filterAndTransformFontFaces, 'family' | 'fonts'>;
+    collectFontAssetsFromFaces: Collaborator<typeof _collectFontAssetsFromFaces, 'family' | 'fonts' | 'collectedFontsIds' | 'fontFilesIds'>;
+}): Promise<{
+    fontFamilyAssets: import("../types.js").FontFamilyAssets[];
+    fontFileById: FontFileById;
+}>;

package/dist/assets/fonts/core/compute-font-families-assets.js

@@ -0,0 +1,67 @@
+async function computeFontFamiliesAssets({
+  resolvedFamilies,
+  fontResolver,
+  logger,
+  bold,
+  defaults,
+  stringMatcher,
+  getOrCreateFontFamilyAssets,
+  collectFontAssetsFromFaces,
+  filterAndTransformFontFaces
+}) {
+  const fontFamilyAssetsByUniqueKey = /* @__PURE__ */ new Map();
+  const fontFileById = /* @__PURE__ */ new Map();
+  for (const family of resolvedFamilies) {
+    const fontAssets = getOrCreateFontFamilyAssets({
+      fontFamilyAssetsByUniqueKey,
+      family
+    });
+    const _fonts = await fontResolver.resolveFont({
+      familyName: family.name,
+      provider: family.provider,
+      // We do not merge the defaults, we only provide defaults as a fallback
+      weights: family.weights ?? defaults.weights,
+      styles: family.styles ?? defaults.styles,
+      subsets: family.subsets ?? defaults.subsets,
+      formats: family.formats ?? defaults.formats,
+      options: family.options
+    });
+    if (_fonts.length === 0) {
+      logger.warn(
+        "assets",
+        `No data found for font family ${bold(family.name)}. Review your configuration`
+      );
+      const availableFamilies = await fontResolver.listFonts({ provider: family.provider });
+      if (availableFamilies && availableFamilies.length > 0 && !availableFamilies.includes(family.name)) {
+        logger.warn(
+          "assets",
+          `${bold(family.name)} font family cannot be retrieved by the provider. Did you mean ${bold(stringMatcher.getClosestMatch(family.name, availableFamilies))}?`
+        );
+      }
+      continue;
+    }
+    fontAssets.fonts.push(
+      ...filterAndTransformFontFaces({
+        fonts: _fonts,
+        family
+      })
+    );
+    const result = collectFontAssetsFromFaces({
+      fonts: fontAssets.fonts,
+      family,
+      fontFilesIds: new Set(fontFileById.keys()),
+      collectedFontsIds: new Set(fontAssets.collectedFontsForMetricsByUniqueKey.keys())
+    });
+    for (const [key, value] of result.fontFileById.entries()) {
+      fontFileById.set(key, value);
+    }
+    for (const [key, value] of result.collectedFontsForMetricsByUniqueKey.entries()) {
+      fontAssets.collectedFontsForMetricsByUniqueKey.set(key, value);
+    }
+    fontAssets.preloads.push(...result.preloads);
+  }
+  return { fontFamilyAssets: Array.from(fontFamilyAssetsByUniqueKey.values()), fontFileById };
+}
+export {
+  computeFontFamiliesAssets
+};

package/dist/assets/fonts/core/filter-and-transform-font-faces.d.ts

@@ -0,0 +1,20 @@
+import type * as unifont from 'unifont';
+import type { FontFileIdGenerator, FontTypeExtractor, UrlResolver } from '../definitions.js';
+import type { ResolvedFontFamily } from '../types.js';
+export declare function filterAndTransformFontFaces({ fonts, fontTypeExtractor, fontFileIdGenerator, urlResolver, family, }: {
+    fonts: Array<unifont.FontFaceData>;
+    fontTypeExtractor: FontTypeExtractor;
+    fontFileIdGenerator: FontFileIdGenerator;
+    urlResolver: UrlResolver;
+    family: Pick<ResolvedFontFamily, 'cssVariable'>;
+}): {
+    src: (unifont.LocalFontSource | unifont.RemoteFontSource)[];
+    display?: "auto" | "block" | "swap" | "fallback" | "optional";
+    weight?: string | number | [number, number];
+    stretch?: string;
+    style?: string;
+    unicodeRange?: string[];
+    featureSettings?: string;
+    variationSettings?: string;
+    meta?: unifont.FontFaceMeta;
+}[];

package/dist/assets/fonts/core/filter-and-transform-font-faces.js

@@ -0,0 +1,39 @@
+import { FONT_FORMATS } from "../constants.js";
+function filterAndTransformFontFaces({
+  fonts,
+  fontTypeExtractor,
+  fontFileIdGenerator,
+  urlResolver,
+  family
+}) {
+  return fonts.filter((font) => typeof font.meta?.priority === "number" ? font.meta.priority <= 1 : true).map((font) => ({
+    ...font,
+    src: font.src.map((source) => {
+      if ("name" in source) {
+        return source;
+      }
+      const originalUrl = source.url.startsWith("//") ? `https:${source.url}` : source.url;
+      let format = FONT_FORMATS.find((e) => e.format === source.format);
+      if (!format) {
+        format = FONT_FORMATS.find((e) => e.type === fontTypeExtractor.extract(source.url));
+      }
+      const id = fontFileIdGenerator.generate({
+        cssVariable: family.cssVariable,
+        font,
+        originalUrl,
+        type: format.type
+      });
+      const url = urlResolver.resolve(id);
+      const newSource = {
+        originalURL: originalUrl,
+        url,
+        format: format.format,
+        tech: source.tech
+      };
+      return newSource;
+    })
+  }));
+}
+export {
+  filterAndTransformFontFaces
+};

package/dist/assets/fonts/core/get-or-create-font-family-assets.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from '../../../core/logger/core.js';
+import type { FontFamilyAssetsByUniqueKey, ResolvedFontFamily } from '../types.js';
+export declare function getOrCreateFontFamilyAssets({ fontFamilyAssetsByUniqueKey, logger, bold, family, }: {
+    fontFamilyAssetsByUniqueKey: FontFamilyAssetsByUniqueKey;
+    logger: Logger;
+    bold: (input: string) => string;
+    family: ResolvedFontFamily;
+}): import("../types.js").FontFamilyAssets;

package/dist/assets/fonts/core/get-or-create-font-family-assets.js

@@ -0,0 +1,34 @@
+function getOrCreateFontFamilyAssets({
+  fontFamilyAssetsByUniqueKey,
+  logger,
+  bold,
+  family
+}) {
+  const key = `${family.cssVariable}:${family.name}:${family.provider.name}`;
+  let fontAssets = fontFamilyAssetsByUniqueKey.get(key);
+  if (!fontAssets) {
+    if (Array.from(fontFamilyAssetsByUniqueKey.keys()).find(
+      (k) => k.startsWith(`${family.cssVariable}:`)
+    )) {
+      logger.warn(
+        "assets",
+        `Several font families have been registered for the ${bold(family.cssVariable)} cssVariable but they do not share the same name and provider.`
+      );
+      logger.warn(
+        "assets",
+        "These families will not be merged together. The last occurrence will override previous families for this cssVariable. Review your Astro configuration."
+      );
+    }
+    fontAssets = {
+      family,
+      fonts: [],
+      collectedFontsForMetricsByUniqueKey: /* @__PURE__ */ new Map(),
+      preloads: []
+    };
+    fontFamilyAssetsByUniqueKey.set(key, fontAssets);
+  }
+  return fontAssets;
+}
+export {
+  getOrCreateFontFamilyAssets
+};