astro 5.16.13 → 5.16.14

package/dist/assets/fonts/core/optimize-fallbacks.d.ts

@@ -4,11 +4,10 @@ import type { FontFileData, ResolvedFontFamily } from '../types.js';
 export interface CollectedFontForMetrics extends FontFileData {
     data: Partial<unifont.FontFaceData>;
 }
-export declare function optimizeFallbacks({ family, fallbacks: _fallbacks, collectedFonts, enabled, systemFallbacksProvider, fontMetricsResolver, }: {
-    family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
+export declare function optimizeFallbacks({ family, fallbacks: _fallbacks, collectedFonts, systemFallbacksProvider, fontMetricsResolver, }: {
+    family: Pick<ResolvedFontFamily, 'name' | 'uniqueName'>;
     fallbacks: Array<string>;
     collectedFonts: Array<CollectedFontForMetrics>;
-    enabled: boolean;
     systemFallbacksProvider: SystemFallbacksProvider;
     fontMetricsResolver: FontMetricsResolver;
 }): Promise<null | {

package/dist/assets/fonts/core/optimize-fallbacks.js

@@ -3,12 +3,11 @@ async function optimizeFallbacks({
   family,
   fallbacks: _fallbacks,
   collectedFonts,
-  enabled,
   systemFallbacksProvider,
   fontMetricsResolver
 }) {
   let fallbacks = [..._fallbacks];
-  if (fallbacks.length === 0 || !enabled || collectedFonts.length === 0) {
+  if (fallbacks.length === 0 || collectedFonts.length === 0) {
     return null;
   }
   const lastFallback = fallbacks[fallbacks.length - 1];
@@ -25,7 +24,7 @@ async function optimizeFallbacks({
   const localFontsMappings = localFonts.map((font) => ({
     font,
     // We mustn't wrap in quote because that's handled by the CSS renderer
-    name: `${family.nameWithHash} fallback: ${font}`
+    name: `${family.uniqueName} fallback: ${font}`
   }));
   fallbacks = [...localFontsMappings.map((m) => m.name), ...fallbacks];
   let css = "";

package/dist/assets/fonts/core/resolve-family.d.ts

@@ -0,0 +1,6 @@
+import type { Hasher } from '../definitions.js';
+import type { FontFamily, ResolvedFontFamily } from '../types.js';
+export declare function resolveFamily({ family, hasher, }: {
+    family: FontFamily;
+    hasher: Hasher;
+}): ResolvedFontFamily;

package/dist/assets/fonts/core/resolve-family.js

@@ -0,0 +1,23 @@
+import { dedupe, withoutQuotes } from "../utils.js";
+function resolveFamily({
+  family,
+  hasher
+}) {
+  const name = withoutQuotes(family.name);
+  return {
+    ...family,
+    name,
+    // This will be used in CSS font faces. Quotes are added by the CSS renderer if
+    // this value contains a space.
+    uniqueName: `${name}-${hasher.hashObject(family)}`,
+    weights: family.weights ? dedupe(family.weights.map((weight) => weight.toString())) : void 0,
+    styles: family.styles ? dedupe(family.styles) : void 0,
+    subsets: family.subsets ? dedupe(family.subsets) : void 0,
+    formats: family.formats ? dedupe(family.formats) : void 0,
+    fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0,
+    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0
+  };
+}
+export {
+  resolveFamily
+};

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

@@ -1,39 +1,17 @@
 import type * as unifont from 'unifont';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
-import type { FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, PreloadData, ResolveFontOptions, Style } from './types.js';
+import type { CssProperties, FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, ResolveFontOptions, Style } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
     hashObject: (input: Record<string, any>) => string;
 }
-export interface LocalProviderUrlResolver {
-    resolve: (input: string) => string;
-}
-export interface ProxyData {
-    weight: unifont.FontFaceData['weight'];
-    style: unifont.FontFaceData['style'];
-    subset: NonNullable<unifont.FontFaceData['meta']>['subset'];
-}
-export interface UrlProxy {
-    proxy: (input: Pick<FontFileData, 'url' | 'init'> & {
-        type: FontType;
-        collectPreload: boolean;
-        data: ProxyData;
-    }) => string;
-}
 export interface UrlResolver {
-    resolve: (hash: string) => string;
+    resolve: (id: string) => string;
     readonly cspResources: Array<string>;
 }
-export interface UrlProxyContentResolver {
+export interface FontFileContentResolver {
     resolve: (url: string) => string;
 }
-export interface DataCollector {
-    collect: (input: FontFileData & {
-        data: ProxyData;
-        preload: PreloadData | null;
-    }) => void;
-}
-export type CssProperties = Record<string, string | undefined>;
 export interface CssRenderer {
     generateFontFace: (family: string, properties: CssProperties) => string;
     generateCssVariable: (key: string, values: Array<string>) => string;
@@ -67,12 +45,12 @@ export interface FontFileReader {
         style: Style;
     };
 }
-export interface UrlProxyHashResolver {
-    resolve: (input: {
+export interface FontFileIdGenerator {
+    generate: (input: {
         originalUrl: string;
         type: FontType;
         cssVariable: string;
-        data: ProxyData;
+        font: unifont.FontFaceData;
     }) => string;
 }
 export interface StringMatcher {

package/dist/assets/fonts/infra/build-font-file-id-generator.d.ts

@@ -0,0 +1,13 @@
+import type { FontFileContentResolver, FontFileIdGenerator, Hasher } from '../definitions.js';
+import type { FontType } from '../types.js';
+export declare class BuildFontFileIdGenerator implements FontFileIdGenerator {
+    #private;
+    constructor({ hasher, contentResolver, }: {
+        hasher: Hasher;
+        contentResolver: FontFileContentResolver;
+    });
+    generate({ originalUrl, type }: {
+        originalUrl: string;
+        type: FontType;
+    }): string;
+}

package/dist/assets/fonts/infra/{build-url-proxy-hash-resolver.js → build-font-file-id-generator.js}

@@ -1,4 +1,4 @@
-class BuildUrlProxyHashResolver {
+class BuildFontFileIdGenerator {
   #hasher;
   #contentResolver;
   constructor({
@@ -8,13 +8,10 @@ class BuildUrlProxyHashResolver {
     this.#hasher = hasher;
     this.#contentResolver = contentResolver;
   }
-  resolve({
-    originalUrl,
-    type
-  }) {
+  generate({ originalUrl, type }) {
     return `${this.#hasher.hashString(this.#contentResolver.resolve(originalUrl))}.${type}`;
   }
 }
 export {
-  BuildUrlProxyHashResolver
+  BuildFontFileIdGenerator
 };

package/dist/assets/fonts/infra/build-url-resolver.d.ts

@@ -7,6 +7,6 @@ export declare class BuildUrlResolver implements UrlResolver {
         assetsPrefix: AssetsPrefix;
         searchParams: URLSearchParams;
     });
-    resolve(hash: string): string;
+    resolve(id: string): string;
     get cspResources(): Array<string>;
 }

package/dist/assets/fonts/infra/build-url-resolver.js

@@ -15,15 +15,15 @@ class BuildUrlResolver {
     this.#assetsPrefix = assetsPrefix;
     this.#searchParams = searchParams;
   }
-  resolve(hash) {
-    const prefix = this.#assetsPrefix ? getAssetsPrefix(fileExtension(hash), this.#assetsPrefix) : void 0;
+  resolve(id) {
+    const prefix = this.#assetsPrefix ? getAssetsPrefix(fileExtension(id), this.#assetsPrefix) : void 0;
     let urlPath;
     if (prefix) {
       this.#resources.add(prefix);
-      urlPath = joinPaths(prefix, this.#base, hash);
+      urlPath = joinPaths(prefix, this.#base, id);
     } else {
       this.#resources.add("'self'");
-      urlPath = prependForwardSlash(joinPaths(this.#base, hash));
+      urlPath = prependForwardSlash(joinPaths(this.#base, id));
     }
     const url = createPlaceholderURL(urlPath);
     this.#searchParams.forEach((value, key) => {

package/dist/assets/fonts/infra/cached-font-fetcher.d.ts

@@ -7,5 +7,5 @@ export declare class CachedFontFetcher implements FontFetcher {
         fetch: (url: string, init?: RequestInit) => Promise<Response>;
         readFile: (url: string) => Promise<Buffer>;
     });
-    fetch({ hash, url, init }: FontFileData): Promise<Buffer>;
+    fetch({ id, url, init }: FontFileData): Promise<Buffer>;
 }

package/dist/assets/fonts/infra/cached-font-fetcher.js

@@ -1,6 +1,5 @@
 import { isAbsolute } from "node:path";
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
-import { cache } from "../utils.js";
 class CachedFontFetcher {
   #storage;
   #fetch;
@@ -14,8 +13,17 @@ class CachedFontFetcher {
     this.#fetch = fetch;
     this.#readFile = readFile;
   }
-  async fetch({ hash, url, init }) {
-    return await cache(this.#storage, hash, async () => {
+  async #cache(storage, key, cb) {
+    const existing = await storage.getItemRaw(key);
+    if (existing) {
+      return existing;
+    }
+    const data = await cb();
+    await storage.setItemRaw(key, data);
+    return data;
+  }
+  async fetch({ id, url, init }) {
+    return await this.#cache(this.#storage, id, async () => {
       try {
         if (isAbsolute(url)) {
           return await this.#readFile(url);

package/dist/assets/fonts/infra/capsize-font-metrics-resolver.d.ts

@@ -1,6 +1,6 @@
 import type { CollectedFontForMetrics } from '../core/optimize-fallbacks.js';
-import type { CssProperties, CssRenderer, FontFetcher, FontMetricsResolver } from '../definitions.js';
-import type { FontFaceMetrics } from '../types.js';
+import type { CssRenderer, FontFetcher, FontMetricsResolver } from '../definitions.js';
+import type { CssProperties, FontFaceMetrics } from '../types.js';
 export declare class CapsizeFontMetricsResolver implements FontMetricsResolver {
     #private;
     constructor({ fontFetcher, cssRenderer, }: {

package/dist/assets/fonts/infra/dev-font-file-id-generator.d.ts

@@ -0,0 +1,16 @@
+import type * as unifont from 'unifont';
+import type { FontFileContentResolver, FontFileIdGenerator, Hasher } from '../definitions.js';
+import type { FontType } from '../types.js';
+export declare class DevFontFileIdGenerator implements FontFileIdGenerator {
+    #private;
+    constructor({ hasher, contentResolver, }: {
+        hasher: Hasher;
+        contentResolver: FontFileContentResolver;
+    });
+    generate({ cssVariable, originalUrl, type, font, }: {
+        originalUrl: string;
+        type: FontType;
+        cssVariable: string;
+        font: unifont.FontFaceData;
+    }): string;
+}

package/dist/assets/fonts/infra/{dev-url-proxy-hash-resolver.js → dev-font-file-id-generator.js}

@@ -1,4 +1,4 @@
-class DevUrlProxyHashResolver {
+class DevFontFileIdGenerator {
   #hasher;
   #contentResolver;
   constructor({
@@ -17,21 +17,21 @@ class DevUrlProxyHashResolver {
     }
     return weight?.replace(/\s+/g, "-");
   }
-  resolve({
+  generate({
     cssVariable,
-    data,
     originalUrl,
-    type
+    type,
+    font
   }) {
     return [
       cssVariable.slice(2),
-      this.#formatWeight(data.weight),
-      data.style,
-      data.subset,
+      this.#formatWeight(font.weight),
+      font.style,
+      font.meta?.subset,
       `${this.#hasher.hashString(this.#contentResolver.resolve(originalUrl))}.${type}`
     ].filter(Boolean).join("-");
   }
 }
 export {
-  DevUrlProxyHashResolver
+  DevFontFileIdGenerator
 };

package/dist/assets/fonts/infra/dev-url-resolver.d.ts

@@ -5,6 +5,6 @@ export declare class DevUrlResolver implements UrlResolver {
         base: string;
         searchParams: URLSearchParams;
     });
-    resolve(hash: string): string;
+    resolve(id: string): string;
     get cspResources(): Array<string>;
 }

package/dist/assets/fonts/infra/dev-url-resolver.js

@@ -11,9 +11,9 @@ class DevUrlResolver {
     this.#base = base;
     this.#searchParams = searchParams;
   }
-  resolve(hash) {
+  resolve(id) {
     this.#resolved ||= true;
-    const urlPath = prependForwardSlash(joinPaths(this.#base, hash));
+    const urlPath = prependForwardSlash(joinPaths(this.#base, id));
     const url = createPlaceholderURL(urlPath);
     this.#searchParams.forEach((value, key) => {
       url.searchParams.set(key, value);

package/dist/assets/fonts/infra/fs-font-file-content-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { FontFileContentResolver } from '../definitions.js';
+type ReadFileSync = (path: string) => string;
+export declare class FsFontFileContentResolver implements FontFileContentResolver {
+    #private;
+    constructor({ readFileSync }: {
+        readFileSync: ReadFileSync;
+    });
+    resolve(url: string): string;
+}
+export {};

package/dist/assets/fonts/infra/fs-font-file-content-resolver.js

@@ -0,0 +1,21 @@
+import { isAbsolute } from "node:path";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+class FsFontFileContentResolver {
+  #readFileSync;
+  constructor({ readFileSync }) {
+    this.#readFileSync = readFileSync;
+  }
+  resolve(url) {
+    if (!isAbsolute(url)) {
+      return url;
+    }
+    try {
+      return url + this.#readFileSync(url);
+    } catch (cause) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+    }
+  }
+}
+export {
+  FsFontFileContentResolver
+};

package/dist/assets/fonts/infra/minifiable-css-renderer.d.ts

@@ -1,4 +1,5 @@
-import type { CssProperties, CssRenderer } from '../definitions.js';
+import type { CssRenderer } from '../definitions.js';
+import type { CssProperties } from '../types.js';
 export declare function renderFontFace(properties: CssProperties, minify: boolean): string;
 export declare function renderCssVariable(key: string, values: Array<string>, minify: boolean): string;
 export declare function withFamily(family: string, properties: CssProperties): CssProperties;

package/dist/assets/fonts/infra/{font-type-extractor.d.ts → node-font-type-extractor.d.ts}

@@ -1,5 +1,5 @@
 import type { FontTypeExtractor } from '../definitions.js';
 import type { FontType } from '../types.js';
-export declare class RealFontTypeExtractor implements FontTypeExtractor {
+export declare class NodeFontTypeExtractor implements FontTypeExtractor {
     extract(url: string): FontType;
 }

package/dist/assets/fonts/infra/{font-type-extractor.js → node-font-type-extractor.js}

@@ -1,7 +1,7 @@
 import { extname } from "node:path";
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { isFontType } from "../utils.js";
-class RealFontTypeExtractor {
+class NodeFontTypeExtractor {
   extract(url) {
     const extension = extname(url).slice(1);
     if (!isFontType(extension)) {
@@ -17,5 +17,5 @@ class RealFontTypeExtractor {
   }
 }
 export {
-  RealFontTypeExtractor
+  NodeFontTypeExtractor
 };

package/dist/assets/fonts/infra/unifont-font-resolver.d.ts

@@ -12,15 +12,17 @@ export declare class UnifontFontResolver implements FontResolver {
         hasher: Hasher;
         provider: FontProvider;
     }): string;
-    static astroToUnifontProvider(astroProvider: FontProvider): Provider;
-    static extractUnifontProviders({ families, hasher, }: {
+    static astroToUnifontProvider(astroProvider: FontProvider, root: URL): Provider;
+    static extractUnifontProviders({ families, hasher, root, }: {
         families: Array<ResolvedFontFamily>;
         hasher: Hasher;
+        root: URL;
     }): NonEmptyProviders;
-    static create({ families, hasher, storage, }: {
+    static create({ families, hasher, storage, root, }: {
         families: Array<ResolvedFontFamily>;
         hasher: Hasher;
         storage: Storage;
+        root: URL;
     }): Promise<UnifontFontResolver>;
     resolveFont({ familyName, provider, options, ...rest }: ResolveFontOptions<Record<string, any>> & {
         provider: FontProvider;

package/dist/assets/fonts/infra/unifont-font-resolver.js

@@ -1,5 +1,4 @@
 import { createUnifont, defineFontProvider } from "unifont";
-import { LOCAL_PROVIDER_NAME } from "../constants.js";
 class UnifontFontResolver {
   #unifont;
   #hasher;
@@ -17,9 +16,9 @@ class UnifontFontResolver {
     });
     return `${provider.name}-${hash}`;
   }
-  static astroToUnifontProvider(astroProvider) {
+  static astroToUnifontProvider(astroProvider, root) {
     return defineFontProvider(astroProvider.name, async (_options, ctx) => {
-      await astroProvider?.init?.(ctx);
+      await astroProvider?.init?.({ ...ctx, root });
       return {
         async resolveFont(familyName, { options, ...rest }) {
           return await astroProvider.resolveFont({ familyName, options, ...rest });
@@ -32,16 +31,14 @@ class UnifontFontResolver {
   }
   static extractUnifontProviders({
     families,
-    hasher
+    hasher,
+    root
   }) {
     const providers = /* @__PURE__ */ new Map();
     for (const { provider } of families) {
-      if (provider === LOCAL_PROVIDER_NAME) {
-        continue;
-      }
       const id = this.idFromProvider({ hasher, provider });
       if (!providers.has(id)) {
-        const unifontProvider = this.astroToUnifontProvider(provider);
+        const unifontProvider = this.astroToUnifontProvider(provider, root);
         unifontProvider._name = this.idFromProvider({ hasher, provider });
         providers.set(id, unifontProvider);
       }
@@ -51,10 +48,11 @@ class UnifontFontResolver {
   static async create({
     families,
     hasher,
-    storage
+    storage,
+    root
   }) {
     return new UnifontFontResolver({
-      unifont: await createUnifont(this.extractUnifontProviders({ families, hasher }), {
+      unifont: await createUnifont(this.extractUnifontProviders({ families, hasher, root }), {
         storage,
         // TODO: consider enabling, would require new astro errors
         throwOnError: false
@@ -68,22 +66,21 @@ class UnifontFontResolver {
     options,
     ...rest
   }) {
+    const id = UnifontFontResolver.idFromProvider({
+      hasher: this.#hasher,
+      provider
+    });
     const { fonts } = await this.#unifont.resolveFont(
       familyName,
       {
         // Options are currently namespaced by provider name, it may change in
         // https://github.com/unjs/unifont/pull/287
         options: {
-          [provider.name]: options
+          [id]: options
         },
         ...rest
       },
-      [
-        UnifontFontResolver.idFromProvider({
-          hasher: this.#hasher,
-          provider
-        })
-      ]
+      [id]
     );
     return fonts;
   }

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

@@ -1,5 +1,6 @@
 import { type AdobeProviderOptions, type GoogleFamilyOptions, type GoogleiconsFamilyOptions } from 'unifont';
 import type { FontProvider } from '../types.js';
+import { type LocalFamilyOptions } from './local.js';
 /** [Adobe](https://fonts.adobe.com/) */
 declare function adobe(config: AdobeProviderOptions): FontProvider;
 /** [Bunny](https://fonts.bunny.net/) */
@@ -12,14 +13,17 @@ declare function fontsource(): FontProvider;
 declare function google(): FontProvider<GoogleFamilyOptions | undefined>;
 /** [Google Icons](https://fonts.google.com/icons) */
 declare function googleicons(): FontProvider<GoogleiconsFamilyOptions | undefined>;
+/** A provider that handles local files. */
+declare function local(): FontProvider<LocalFamilyOptions>;
 /**
- * Astro re-exports most [unifont](https://github.com/unjs/unifont/) providers:
+ * Astro exports a few built-in providers:
  * - [Adobe](https://fonts.adobe.com/)
  * - [Bunny](https://fonts.bunny.net/)
  * - [Fontshare](https://www.fontshare.com/)
  * - [Fontsource](https://fontsource.org/)
  * - [Google](https://fonts.google.com/)
  * - [Google Icons](https://fonts.google.com/icons)
+ * - Local
  */
 export declare const fontProviders: {
     adobe: typeof adobe;
@@ -28,5 +32,6 @@ export declare const fontProviders: {
     fontsource: typeof fontsource;
     google: typeof google;
     googleicons: typeof googleicons;
+    local: typeof local;
 };
 export {};

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

@@ -1,6 +1,8 @@
 import {
   providers
 } from "unifont";
+import { FontaceFontFileReader } from "../infra/fontace-font-file-reader.js";
+import { LocalFontProvider } from "./local.js";
 function adobe(config) {
   const provider = providers.adobe(config);
   let initializedProvider;
@@ -98,13 +100,19 @@ function googleicons() {
     }
   };
 }
+function local() {
+  return new LocalFontProvider({
+    fontFileReader: new FontaceFontFileReader()
+  });
+}
 const fontProviders = {
   adobe,
   bunny,
   fontshare,
   fontsource,
   google,
-  googleicons
+  googleicons,
+  local
 };
 export {
   fontProviders

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

@@ -1,11 +1,44 @@
 import type * as unifont from 'unifont';
-import type { FontFileReader, FontTypeExtractor, UrlProxy } from '../definitions.js';
-import type { ResolvedLocalFontFamily } from '../types.js';
-interface Options {
-    family: ResolvedLocalFontFamily;
-    urlProxy: UrlProxy;
-    fontTypeExtractor: FontTypeExtractor;
-    fontFileReader: FontFileReader;
+import type { FontFileReader } from '../definitions.js';
+import type { FamilyProperties, FontProvider, FontProviderInitContext, ResolveFontOptions, Style, Weight } from '../types.js';
+type RawSource = string | URL | {
+    url: string | URL;
+    tech?: string | undefined;
+};
+interface Variant extends FamilyProperties {
+    /**
+     * Font [sources](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src). It can be a path relative to the root, a package import or a URL. URLs are particularly useful if you inject local fonts through an integration.
+     */
+    src: [RawSource, ...Array<RawSource>];
+    /**
+     * 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:
+     *
+     * ```js
+     * weight: "100 900"
+     * ```
+     */
+    weight?: Weight | undefined;
+    /**
+     * A [font style](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style).
+     */
+    style?: Style | undefined;
+}
+export interface LocalFamilyOptions {
+    /**
+     * Each variant represents a [`@font-face` declaration](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/).
+     */
+    variants: [Variant, ...Array<Variant>];
+}
+export declare class LocalFontProvider implements FontProvider<LocalFamilyOptions> {
+    #private;
+    name: string;
+    config?: Record<string, any> | undefined;
+    constructor({ fontFileReader, }: {
+        fontFileReader: FontFileReader;
+    });
+    init(context: Pick<FontProviderInitContext, 'root'>): void;
+    resolveFont(options: ResolveFontOptions<LocalFamilyOptions>): {
+        fonts: Array<unifont.FontFaceData>;
+    };
 }
-export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor, fontFileReader, }: Options): Array<unifont.FontFaceData>;
 export {};