astro 5.16.13 → 5.16.15

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

@@ -1,208 +1,11 @@
 import { z } from 'zod';
+import type { FontProvider } from './types.js';
 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>>;
-    init: z.ZodOptional<z.ZodType<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, z.ZodTypeDef, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
-    resolveFont: z.ZodType<(options: import("./types.js").ResolveFontOptions<never>) => {
-        fonts: Array<import("unifont").FontFaceData>;
-    } | Promise<{
-        fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions<never>) => {
-        fonts: Array<import("unifont").FontFaceData>;
-    } | Promise<{
-        fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined>;
-    listFonts: z.ZodOptional<z.ZodType<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, z.ZodTypeDef, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
-        fonts: Array<import("unifont").FontFaceData>;
-    } | Promise<{
-        fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined;
-    config?: Record<string, any> | undefined;
-    init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
-    listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
-}, {
-    name: string;
-    resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
-        fonts: Array<import("unifont").FontFaceData>;
-    } | Promise<{
-        fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined;
-    config?: Record<string, any> | undefined;
-    init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
-    listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
-}>;
-export declare const remoteFontFamilySchema: z.ZodObject<{
-    provider: z.ZodObject<{
-        name: z.ZodString;
-        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        init: z.ZodOptional<z.ZodType<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, z.ZodTypeDef, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
-        resolveFont: z.ZodType<(options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined>;
-        listFonts: z.ZodOptional<z.ZodType<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, z.ZodTypeDef, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
-    }, "strict", z.ZodTypeAny, {
-        name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined;
-        config?: Record<string, any> | undefined;
-        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
-        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
-    }, {
-        name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined;
-        config?: Record<string, any> | undefined;
-        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
-        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
-    }>;
+export declare const fontProviderSchema: z.ZodType<FontProvider<never>, z.ZodTypeDef, FontProvider<never>>;
+export declare const fontFamilySchema: z.ZodObject<{
+    provider: z.ZodType<FontProvider<never>, z.ZodTypeDef, FontProvider<never>>;
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     weights: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "atleastone">>;
     styles: z.ZodOptional<z.ZodArray<z.ZodEnum<["normal", "italic", "oblique"]>, "atleastone">>;
@@ -220,53 +23,33 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     name: string;
     cssVariable: string;
-    provider: {
-        name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined;
-        config?: Record<string, any> | undefined;
-        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
-        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
-    };
-    options?: Record<string, any> | undefined;
+    provider: FontProvider<never>;
+    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;
+    options?: Record<string, any> | undefined;
+}, {
+    name: string;
+    cssVariable: string;
+    provider: FontProvider<never>;
     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;
-}, {
-    name: string;
-    cssVariable: string;
-    provider: {
-        name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined;
-        config?: Record<string, any> | undefined;
-        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
-        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
-    };
-    options?: Record<string, any> | 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,32 +20,17 @@ 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({
+const _fontProviderSchema = z.object({
   name: z.string(),
   config: z.record(z.string(), z.any()).optional(),
   init: z.custom((v) => typeof v === "function").optional(),
   resolveFont: z.custom((v) => typeof v === "function"),
   listFonts: z.custom((v) => typeof v === "function").optional()
 }).strict();
-const remoteFontFamilySchema = z.object({
+const fontProviderSchema = z.custom((v) => {
+  return _fontProviderSchema.safeParse(v).success;
+}, "Invalid FontProvider object");
+const fontFamilySchema = z.object({
   ...requiredFamilyAttributesSchema.shape,
   ...fallbacksSchema.shape,
   ...familyPropertiesSchema.omit({
@@ -61,9 +46,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
+};