astro 5.16.13 → 5.16.15

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 {};

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

@@ -1,52 +1,69 @@
-import { FONT_FORMATS } from "../constants.js";
-function resolveLocalFont({
-  family,
-  urlProxy,
-  fontTypeExtractor,
-  fontFileReader
-}) {
-  return family.variants.map((variant) => {
-    const shouldInfer = variant.weight === void 0 || variant.style === void 0;
-    const data = {
-      // If it should be inferred, we don't want to set the value
-      weight: variant.weight,
-      style: variant.style,
-      src: [],
-      unicodeRange: variant.unicodeRange,
-      display: variant.display,
-      stretch: variant.stretch,
-      featureSettings: variant.featureSettings,
-      variationSettings: variant.variationSettings
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+class LocalFontProvider {
+  name = "local";
+  config;
+  #fontFileReader;
+  #root;
+  constructor({
+    fontFileReader
+  }) {
+    this.config = void 0;
+    this.#fontFileReader = fontFileReader;
+    this.#root = void 0;
+  }
+  init(context) {
+    this.#root = context.root;
+  }
+  #resolveEntrypoint(root, entrypoint) {
+    const require2 = createRequire(root);
+    try {
+      return pathToFileURL(require2.resolve(entrypoint));
+    } catch {
+      return new URL(entrypoint, root);
+    }
+  }
+  #normalizeSource(value) {
+    const isValue = typeof value === "string" || value instanceof URL;
+    const url = (isValue ? value : value.url).toString();
+    const tech = isValue ? void 0 : value.tech;
+    return {
+      url: fileURLToPath(this.#resolveEntrypoint(this.#root ?? new URL(import.meta.url), url)),
+      tech
     };
-    data.src = variant.src.map((source, index) => {
-      if (shouldInfer && index === 0) {
-        const result = fontFileReader.extract({ family: family.name, url: source.url });
-        if (variant.weight === void 0) data.weight = result.weight;
-        if (variant.style === void 0) data.style = result.style;
-      }
-      const type = fontTypeExtractor.extract(source.url);
-      return {
-        originalURL: source.url,
-        url: urlProxy.proxy({
-          url: source.url,
-          type,
-          // We only use the first source for preloading. For example if woff2 and woff
-          // are available, we only keep woff2.
-          collectPreload: index === 0,
-          data: {
-            weight: data.weight,
-            style: data.style,
-            subset: void 0
-          },
-          init: null
-        }),
-        format: FONT_FORMATS.find((e) => e.type === type)?.format,
-        tech: source.tech
-      };
-    });
-    return data;
-  });
+  }
+  resolveFont(options) {
+    return {
+      fonts: options.options?.variants.map((variant) => {
+        const shouldInfer = variant.weight === void 0 || variant.style === void 0;
+        const data = {
+          // If it should be inferred, we don't want to set the value
+          weight: variant.weight,
+          style: variant.style,
+          src: [],
+          unicodeRange: variant.unicodeRange,
+          display: variant.display,
+          stretch: variant.stretch,
+          featureSettings: variant.featureSettings,
+          variationSettings: variant.variationSettings
+        };
+        data.src = variant.src.map((rawSource, index) => {
+          const source = this.#normalizeSource(rawSource);
+          if (shouldInfer && index === 0) {
+            const result = this.#fontFileReader.extract({
+              family: options.familyName,
+              url: source.url
+            });
+            if (variant.weight === void 0) data.weight = result.weight;
+            if (variant.style === void 0) data.style = result.style;
+          }
+          return source;
+        });
+        return data;
+      }) ?? []
+    };
+  }
 }
 export {
-  resolveLocalFont
+  LocalFontProvider
 };

package/dist/assets/fonts/runtime/client.d.ts

@@ -1,2 +1,2 @@
-export declare const fontData: import("../types.js").FontDataRecord;
+export declare const fontData: import("../types.js").FontDataByCssVariable;
 export declare function getFontBuffer(): Promise<void>;

package/dist/assets/fonts/runtime/client.js

@@ -1,5 +1,5 @@
 import * as fontsMod from "virtual:astro:assets/fonts/internal";
-const fontData = fontsMod.fontData ?? {};
+const fontData = fontsMod.fontDataByCssVariable ?? {};
 async function getFontBuffer() {
   throw new Error("[astro:assets] `getFontBuffer()` is not available on the client.");
 }

package/dist/assets/fonts/runtime/server.d.ts

@@ -1,2 +1,2 @@
-export declare const fontData: import("../types.js").FontDataRecord;
+export declare const fontData: import("../types.js").FontDataByCssVariable;
 export declare const getFontBuffer: (url: string) => Promise<Buffer<ArrayBufferLike>>;

package/dist/assets/fonts/runtime/server.js

@@ -1,6 +1,6 @@
 import * as fontsMod from "virtual:astro:assets/fonts/internal";
 import { createGetFontBuffer } from "../core/create-get-font-buffer.js";
-const fontData = fontsMod.fontData ?? {};
+const fontData = fontsMod.fontDataByCssVariable ?? {};
 const getFontBuffer = createGetFontBuffer(fontsMod);
 export {
   fontData,

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

@@ -2,11 +2,10 @@ import type { Font } from '@capsizecss/unpack';
 import type * as unifont from 'unifont';
 import type { z } from 'zod';
 import type { displaySchema, styleSchema, weightSchema } from './config.js';
-import type { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from './constants.js';
+import type { FONT_TYPES, GENERIC_FALLBACK_NAMES } from './constants.js';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
-type Weight = z.infer<typeof weightSchema>;
+export type Weight = z.infer<typeof weightSchema>;
 type Display = z.infer<typeof displaySchema>;
-/** @lintignore */
 export interface FontProviderInitContext {
     storage: {
         getItem: {
@@ -15,6 +14,7 @@ export interface FontProviderInitContext {
         };
         setItem: (key: string, value: unknown) => Awaitable<void>;
     };
+    root: URL;
 }
 type Awaitable<T> = T | Promise<T>;
 export interface FontProvider<TFamilyOptions extends Record<string, any> | undefined | never = never> {
@@ -41,56 +41,7 @@ export interface FontProvider<TFamilyOptions extends Record<string, any> | undef
      */
     listFonts?: (() => Awaitable<Array<string> | undefined>) | undefined;
 }
-interface RequiredFamilyAttributes {
-    /**
-     * The font family name, as identified by your font provider.
-     */
-    name: string;
-    /**
-     * A valid [ident](https://developer.mozilla.org/en-US/docs/Web/CSS/ident) in the form of a CSS variable (i.e. starting with `--`).
-     */
-    cssVariable: string;
-}
-interface Fallbacks {
-    /**
-     * @default `["sans-serif"]`
-     *
-     * An array of fonts to use when your chosen font is unavailable, or loading. Fallback fonts will be chosen in the order listed. The first available font will be used:
-     *
-     * ```js
-     * fallbacks: ["CustomFont", "serif"]
-     * ```
-     *
-     * To disable fallback fonts completely, configure an empty array:
-     *
-     * ```js
-     * fallbacks: []
-     * ```
-     *
-
-     * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), Astro will attempt to generate [optimized fallbacks](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
-     */
-    fallbacks?: Array<string> | undefined;
-    /**
-     * @default `true`
-     *
-     * Whether or not to enable optimized fallback generation. You may disable this default optimization to have full control over `fallbacks`.
-     */
-    optimizedFallbacks?: boolean | undefined;
-}
-interface FamilyProperties {
-    /**
-     * 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 FamilyProperties {
     /**
      * @default `"swap"`
      *
@@ -114,38 +65,6 @@ interface FamilyProperties {
      */
     unicodeRange?: [string, ...Array<string>] | undefined;
 }
-type Src = 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: [Src, ...Array<Src>];
-}
-export interface LocalFontFamily extends RequiredFamilyAttributes, Fallbacks {
-    /**
-     * The source of your font files. Set to `"local"` to use local font files.
-     */
-    provider: typeof LOCAL_PROVIDER_NAME;
-    /**
-     * Each variant represents a [`@font-face` declaration](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/).
-     */
-    variants: [Variant, ...Array<Variant>];
-}
-interface ResolvedFontFamilyAttributes {
-    nameWithHash: string;
-}
-export interface ResolvedLocalFontFamily extends ResolvedFontFamilyAttributes, Omit<LocalFontFamily, 'variants'> {
-    variants: Array<Omit<LocalFontFamily['variants'][number], 'weight' | 'src'> & {
-        weight?: string;
-        src: Array<{
-            url: string;
-            tech?: string;
-        }>;
-    }>;
-}
 type WithOptions<TFontProvider extends FontProvider> = TFontProvider extends FontProvider<infer TFamilyOptions> ? [TFamilyOptions] extends [never] ? {
     /**
      * Options forwarded to the font provider while resolving this font family.
@@ -167,7 +86,15 @@ type WithOptions<TFontProvider extends FontProvider> = TFontProvider extends Fon
      */
     options?: undefined;
 };
-export type RemoteFontFamily<TFontProvider extends FontProvider = FontProvider> = RequiredFamilyAttributes & Omit<FamilyProperties, 'weight' | 'style' | 'subsets' | 'formats'> & Fallbacks & WithOptions<NoInfer<TFontProvider>> & {
+export type FontFamily<TFontProvider extends FontProvider = FontProvider> = FamilyProperties & WithOptions<NoInfer<TFontProvider>> & {
+    /**
+     * The font family name, as identified by your font provider.
+     */
+    name: string;
+    /**
+     * A valid [ident](https://developer.mozilla.org/en-US/docs/Web/CSS/ident) in the form of a CSS variable (i.e. starting with `--`).
+     */
+    cssVariable: string;
     /**
      * The source of your font files. You can use a built-in provider or write your own custom provider.
      */
@@ -200,13 +127,36 @@ export type RemoteFontFamily<TFontProvider extends FontProvider = FontProvider>
      * An array of [font formats](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@font-face/src#font_formats).
      */
     formats?: [FontType, ...Array<FontType>] | undefined;
+    /**
+ * @default `["sans-serif"]`
+ *
+ * An array of fonts to use when your chosen font is unavailable, or loading. Fallback fonts will be chosen in the order listed. The first available font will be used:
+ *
+ * ```js
+ * fallbacks: ["CustomFont", "serif"]
+ * ```
+ *
+ * To disable fallback fonts completely, configure an empty array:
+ *
+ * ```js
+ * fallbacks: []
+ * ```
+ *
+
+ * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), Astro will attempt to generate [optimized fallbacks](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
+ */
+    fallbacks?: Array<string> | undefined;
+    /**
+     * @default `true`
+     *
+     * Whether or not to enable optimized fallback generation. You may disable this default optimization to have full control over `fallbacks`.
+     */
+    optimizedFallbacks?: boolean | undefined;
 };
-/** @lintignore somehow required by pickFontFaceProperty in utils */
-export interface ResolvedRemoteFontFamily extends ResolvedFontFamilyAttributes, Omit<RemoteFontFamily, 'weights'> {
+export interface ResolvedFontFamily extends Omit<FontFamily, 'weights'> {
+    uniqueName: string;
     weights?: Array<string>;
 }
-export type FontFamily<TFontProvider extends FontProvider = FontProvider> = LocalFontFamily | RemoteFontFamily<TFontProvider>;
-export type ResolvedFontFamily = ResolvedLocalFontFamily | ResolvedRemoteFontFamily;
 export type FontType = (typeof FONT_TYPES)[number];
 /**
  * Preload data is used for links generation inside the <Font /> component
@@ -226,30 +176,19 @@ export interface PreloadData {
 }
 export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
 export type GenericFallbackName = (typeof GENERIC_FALLBACK_NAMES)[number];
-export type Defaults = Required<Pick<ResolvedRemoteFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks' | 'formats'>>;
+export type Defaults = Required<Pick<ResolvedFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks' | 'formats'>>;
 export interface FontFileData {
-    hash: string;
+    id: string;
     url: string;
-    init: RequestInit | null;
-}
-export interface CreateUrlProxyParams {
-    local: boolean;
-    hasUrl: (hash: string) => boolean;
-    saveUrl: (input: FontFileData) => void;
-    savePreload: (preload: PreloadData) => void;
-    saveFontData: (collected: CollectedFontForMetrics) => void;
-    cssVariable: string;
+    init: RequestInit | undefined;
 }
 /**
- * Holds associations of hash and original font file URLs, so they can be
- * downloaded whenever the hash is requested.
+ * Holds associations of id and original font file URLs, so they can be
+ * downloaded whenever the id is requested.
  */
-export type FontFileDataMap = Map<FontFileData['hash'], Pick<FontFileData, 'url' | 'init'>>;
-/**
- * Holds associations of CSS variables and preloadData/css to be passed to the internal virtual module.
- */
-export type InternalConsumableMap = Map<string, {
-    preloadData: Array<PreloadData>;
+export type FontFileById = Map<FontFileData['id'], Pick<FontFileData, 'url' | 'init'>>;
+export type ComponentDataByCssVariable = Map<string, {
+    preloads: Array<PreloadData>;
     css: string;
 }>;
 export interface FontData {
@@ -264,7 +203,7 @@ export interface FontData {
 /**
  * Holds associations of CSS variables and font data to be exposed via virtual module.
  */
-export type FontDataRecord = Record<string, Array<FontData>>;
+export type FontDataByCssVariable = Record<string, Array<FontData>>;
 export type Style = z.output<typeof styleSchema>;
 export type PreloadFilter = boolean | Array<{
     weight?: string | number;
@@ -279,6 +218,18 @@ export interface ResolveFontOptions<FamilyOptions extends Record<string, any> |
     formats: FontType[];
     options: [FamilyOptions] extends [never] ? undefined : FamilyOptions | undefined;
 }
+export type CssProperties = Record<string, string | undefined>;
+export interface FontFamilyAssets {
+    family: ResolvedFontFamily;
+    fonts: Array<unifont.FontFaceData>;
+    /**
+     * Holds a list of font files to be used for optimized fallbacks generation
+     */
+    collectedFontsForMetricsByUniqueKey: Map<string, CollectedFontForMetrics>;
+    preloads: Array<PreloadData>;
+}
+export type FontFamilyAssetsByUniqueKey = Map<string, FontFamilyAssets>;
+export type Collaborator<T extends (input: any) => any, U extends keyof Parameters<T>[0]> = (params: Pick<Parameters<T>[0], U>) => ReturnType<T>;
 export type BufferImports = Record<string, () => Promise<{
     default: Buffer | null;
 }>>;

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

@@ -1,6 +1,5 @@
 import type * as unifont from 'unifont';
-import type { CssProperties, Storage } from './definitions.js';
-import type { FontType, GenericFallbackName, ResolvedFontFamily } from './types.js';
+import type { CssProperties, FontType, GenericFallbackName } from './types.js';
 /**
  * Turns unifont font face data into generic CSS properties, to be consumed by the CSS renderer.
  */
@@ -16,11 +15,6 @@ export declare function renderFontSrc(sources: Exclude<unifont.FontFaceData['src
  */
 export declare function withoutQuotes(str: string): string;
 export declare function isFontType(str: string): str is FontType;
-export declare function cache(storage: Storage, key: string, cb: () => Promise<Buffer>): Promise<Buffer>;
 export declare function isGenericFontFamily(str: string): str is GenericFallbackName;
 export declare function dedupe<const T extends Array<any>>(arr: T): T;
 export declare function sortObjectByKey<T extends Record<string, any>>(unordered: T): T;
-export declare function pickFontFaceProperty<T extends keyof Pick<unifont.FontFaceData, 'display' | 'unicodeRange' | 'stretch' | 'featureSettings' | 'variationSettings'>>(property: T, { data, family }: {
-    data: unifont.FontFaceData;
-    family: ResolvedFontFamily;
-}): import("./types.js").ResolvedRemoteFontFamily[T] | NonNullable<unifont.FontFaceData[T]> | undefined;

package/dist/assets/fonts/utils.js

@@ -1,4 +1,4 @@
-import { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from "./constants.js";
+import { FONT_TYPES, GENERIC_FALLBACK_NAMES } from "./constants.js";
 function unifontFontFaceDataToProperties(font) {
   return {
     src: font.src ? renderFontSrc(font.src) : void 0,
@@ -36,15 +36,6 @@ function withoutQuotes(str) {
 function isFontType(str) {
   return FONT_TYPES.includes(str);
 }
-async function 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;
-}
 function isGenericFontFamily(str) {
   return GENERIC_FALLBACK_NAMES.includes(str);
 }
@@ -59,15 +50,10 @@ function sortObjectByKey(unordered) {
   }, {});
   return ordered;
 }
-function pickFontFaceProperty(property, { data, family }) {
-  return data[property] ?? (family.provider === LOCAL_PROVIDER_NAME ? void 0 : family[property]);
-}
 export {
-  cache,
   dedupe,
   isFontType,
   isGenericFontFamily,
-  pickFontFaceProperty,
   renderFontSrc,
   renderFontWeight,
   sortObjectByKey,