astro 5.7.3 → 5.7.5

package/dist/actions/runtime/virtual/server.js

@@ -160,13 +160,15 @@ function getActionContext(context) {
           }
           throw e;
         }
-        const {
-          props: _props,
-          getActionResult: _getActionResult,
-          callAction: _callAction,
-          redirect: _redirect,
-          ...actionAPIContext
-        } = context;
+        const omitKeys = ["props", "getActionResult", "callAction", "redirect"];
+        const actionAPIContext = Object.create(
+          Object.getPrototypeOf(context),
+          Object.fromEntries(
+            Object.entries(Object.getOwnPropertyDescriptors(context)).filter(
+              ([key]) => !omitKeys.includes(key)
+            )
+          )
+        );
         Reflect.set(actionAPIContext, ACTION_API_CONTEXT_SYMBOL, true);
         const handler = baseAction.bind(actionAPIContext);
         return handler(input);

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

@@ -1,20 +1,4 @@
 import { z } from 'zod';
-export declare const requiredFamilyAttributesSchema: z.ZodObject<{
-    /**
-     * The font family name, as identified by your font provider.
-     */
-    name: z.ZodString;
-    /**
-     * 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: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    cssVariable: string;
-}, {
-    name: string;
-    cssVariable: string;
-}>;
 export declare const fontProviderSchema: z.ZodObject<{
     /**
      * URL, path relative to the root or package import.

package/dist/assets/fonts/config.js

@@ -152,6 +152,5 @@ const remoteFontFamilySchema = requiredFamilyAttributesSchema.merge(
 export {
   fontProviderSchema,
   localFontFamilySchema,
-  remoteFontFamilySchema,
-  requiredFamilyAttributesSchema
+  remoteFontFamilySchema
 };

package/dist/assets/fonts/load.js

@@ -28,18 +28,24 @@ async function loadFonts({
   for (const family of families) {
     const preloadData = [];
     let css = "";
-    let fallbackFontData = null;
-    const collect = ({ hash, type, value }) => {
+    const fallbacks = family.fallbacks ?? DEFAULTS.fallbacks;
+    const fallbackFontData = [];
+    const collect = ({ hash, type, value, data }, collectPreload) => {
       const url = base + hash;
       if (!hashToUrlMap.has(hash)) {
         hashToUrlMap.set(hash, value);
-        preloadData.push({ url, type });
+        if (collectPreload) {
+          preloadData.push({ url, type });
+        }
       }
-      if (family.fallbacks && family.fallbacks.length > 0) {
-        fallbackFontData ??= {
+      if (fallbacks && fallbacks.length > 0 && // If the same data has already been sent for this family, we don't want to have duplicate fallbacks
+      // Such scenario can occur with unicode ranges
+      !fallbackFontData.some((f) => JSON.stringify(f.data) === JSON.stringify(data))) {
+        fallbackFontData.push({
           hash,
-          url: value
-        };
+          url: value,
+          data
+        });
       }
       return url;
     };
@@ -47,7 +53,7 @@ async function loadFonts({
     if (family.provider === LOCAL_PROVIDER_NAME) {
       const result = resolveLocalFont({
         family,
-        proxyURL: (value) => {
+        proxyURL: ({ value, data }) => {
           return proxyURL({
             value,
             // We hash based on the filepath and the contents, since the user could replace
@@ -61,7 +67,7 @@ async function loadFonts({
               }
               return hashString(v + content);
             },
-            collect
+            collect: (input) => collect({ ...input, data }, true)
           });
         }
       });
@@ -83,21 +89,40 @@ async function loadFonts({
       );
       fonts = result.fonts.filter(
         (font) => typeof font.meta?.priority === "number" ? font.meta.priority === 0 : true
-      ).map((font) => ({
-        ...font,
-        src: font.src.slice(0, 1).map(
-          (source) => "name" in source ? source : {
-            ...source,
-            originalURL: source.url,
-            url: proxyURL({
-              value: source.url,
-              // We only use the url for hashing since the service returns urls with a hash already
-              hashString,
-              collect
-            })
-          }
-        )
-      }));
+      ).map((font) => {
+        let index = 0;
+        return {
+          ...font,
+          src: font.src.map((source) => {
+            if ("name" in source) {
+              return source;
+            }
+            const proxied = {
+              ...source,
+              originalURL: source.url,
+              url: proxyURL({
+                value: source.url,
+                // We only use the url for hashing since the service returns urls with a hash already
+                hashString,
+                // We only collect the first URL to avoid preloading fallback sources (eg. we only
+                // preload woff2 if woff is available)
+                collect: (data) => collect(
+                  {
+                    ...data,
+                    data: {
+                      weight: font.weight,
+                      style: font.style
+                    }
+                  },
+                  index === 0
+                )
+              })
+            };
+            index++;
+            return proxied;
+          })
+        };
+      });
     }
     for (const data of fonts) {
       css += generateFontFace(family.nameWithHash, {
@@ -114,7 +139,7 @@ async function loadFonts({
     const fallbackData = await generateFallbacksCSS({
       family,
       font: fallbackFontData,
-      fallbacks: family.fallbacks ?? DEFAULTS.fallbacks,
+      fallbacks,
       metrics: family.optimizedFallbacks ?? DEFAULTS.optimizedFallbacks ? {
         getMetricsForFamily,
         generateFontFace: generateFallbackFontFace
@@ -122,7 +147,9 @@ async function loadFonts({
     });
     const cssVarValues = [family.nameWithHash];
     if (fallbackData) {
-      css += fallbackData.css;
+      if (fallbackData.css) {
+        css += fallbackData.css;
+      }
       cssVarValues.push(...fallbackData.fallbacks);
     }
     css += `:root { ${family.cssVariable}: ${cssVarValues.join(", ")}; }`;

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

@@ -6,5 +6,5 @@ export declare function generateFallbackFontFace({ metrics, fallbackMetrics, nam
     fallbackMetrics: FontFaceMetrics;
     name: string;
     font: string;
-    properties?: Record<string, string | undefined>;
+    properties: Record<string, string | undefined>;
 }): string;

package/dist/assets/fonts/metrics.js

@@ -30,7 +30,7 @@ function generateFallbackFontFace({
   fallbackMetrics,
   name: fallbackName,
   font: fallbackFontName,
-  properties = {}
+  properties
 }) {
   const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
   const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;

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

@@ -21,7 +21,7 @@ declare function fontsource(): {
     config?: Record<string, any> | undefined;
 };
 /** [Google](https://fonts.google.com/) */
-declare function google(): {
+declare function google(config?: Parameters<typeof providers.google>[0]): {
     entrypoint: string | URL;
     config?: Record<string, any> | undefined;
 };

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

@@ -19,9 +19,10 @@ function fontsource() {
     entrypoint: "astro/assets/fonts/providers/fontsource"
   });
 }
-function google() {
+function google(config) {
   return defineAstroFontProvider({
-    entrypoint: "astro/assets/fonts/providers/google"
+    entrypoint: "astro/assets/fonts/providers/google",
+    config
   });
 }
 const fontProviders = {

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

@@ -4,7 +4,10 @@ type InitializedProvider = NonNullable<Awaited<ReturnType<unifont.Provider>>>;
 type ResolveFontResult = NonNullable<Awaited<ReturnType<InitializedProvider['resolveFont']>>>;
 interface Options {
     family: ResolvedLocalFontFamily;
-    proxyURL: (value: string) => string;
+    proxyURL: (params: {
+        value: string;
+        data: Partial<unifont.FontFaceData>;
+    }) => string;
 }
 export declare function resolveLocalFont({ family, proxyURL }: Options): ResolveFontResult;
 export {};

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

@@ -9,7 +9,13 @@ function resolveLocalFont({ family, proxyURL }) {
       src: variant.src.map(({ url: originalURL, tech }) => {
         return {
           originalURL,
-          url: proxyURL(originalURL),
+          url: proxyURL({
+            value: originalURL,
+            data: {
+              weight: variant.weight,
+              style: variant.style
+            }
+          }),
           format: FONT_FORMAT_MAP[extractFontType(originalURL)],
           tech
         };

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

@@ -46,6 +46,7 @@ export declare function isGenericFontFamily(str: string): str is keyof typeof DE
 export type GetMetricsForFamilyFont = {
     hash: string;
     url: string;
+    data: Partial<unifont.FontFaceData>;
 };
 export type GetMetricsForFamily = (name: string, 
 /** A remote url or local filepath to a font file. Used if metrics can't be resolved purely from the family name */
@@ -61,13 +62,13 @@ export declare function generateFallbacksCSS({ family, fallbacks: _fallbacks, fo
     family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
     /** The family fallbacks */
     fallbacks: Array<string>;
-    font: GetMetricsForFamilyFont | null;
+    font: Array<GetMetricsForFamilyFont>;
     metrics: {
         getMetricsForFamily: GetMetricsForFamily;
         generateFontFace: typeof generateFallbackFontFace;
     } | null;
 }): Promise<null | {
-    css: string;
+    css?: string;
     fallbacks: Array<string>;
 }>;
 /**

package/dist/assets/fonts/utils.js

@@ -13,10 +13,9 @@ function renderFontFace(properties) {
 }
 `;
 }
-function generateFontFace(family, font) {
-  return renderFontFace({
-    "font-family": family,
-    src: renderFontSrc(font.src),
+function unifontFontFaceDataToProperties(font) {
+  return {
+    src: font.src ? renderFontSrc(font.src) : void 0,
     "font-display": font.display ?? "swap",
     "unicode-range": font.unicodeRange?.join(","),
     "font-weight": Array.isArray(font.weight) ? font.weight.join(" ") : font.weight?.toString(),
@@ -24,6 +23,12 @@ function generateFontFace(family, font) {
     "font-stretch": font.stretch,
     "font-feature-settings": font.featureSettings,
     "font-variation-settings": font.variationSettings
+  };
+}
+function generateFontFace(family, font) {
+  return renderFontFace({
+    "font-family": family,
+    ...unifontFontFaceDataToProperties(font)
   });
 }
 function renderFontSrc(sources) {
@@ -91,35 +96,39 @@ async function generateFallbacksCSS({
   if (fallbacks.length === 0) {
     return null;
   }
-  let css = "";
-  if (!fontData || !metrics) {
-    return { css, fallbacks };
+  if (fontData.length === 0 || !metrics) {
+    return { fallbacks };
   }
   const lastFallback = fallbacks[fallbacks.length - 1];
   if (!isGenericFontFamily(lastFallback)) {
-    return { css, fallbacks };
+    return { fallbacks };
   }
   const localFonts = DEFAULT_FALLBACKS[lastFallback];
   if (localFonts.length === 0) {
-    return { css, fallbacks };
+    return { fallbacks };
   }
-  const foundMetrics = await metrics.getMetricsForFamily(family.name, fontData);
-  if (!foundMetrics) {
-    return { css, fallbacks };
+  if (localFonts.includes(
+    // @ts-expect-error TS is not smart enough
+    family.name
+  )) {
+    return { fallbacks };
   }
   const localFontsMappings = localFonts.map((font) => ({
     font,
     name: `"${family.nameWithHash} fallback: ${font}"`
   }));
   fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
+  let css = "";
   for (const { font, name } of localFontsMappings) {
-    css += metrics.generateFontFace({
-      metrics: foundMetrics,
-      fallbackMetrics: SYSTEM_METRICS[font],
-      font,
-      name
-      // TODO: forward some properties once we generate one fallback per font face data
-    });
+    for (const { hash, url, data } of fontData) {
+      css += metrics.generateFontFace({
+        metrics: await metrics.getMetricsForFamily(family.name, { hash, url, data }),
+        fallbackMetrics: SYSTEM_METRICS[font],
+        font,
+        name,
+        properties: unifontFontFaceDataToProperties(data)
+      });
+    }
   }
   return { css, fallbacks };
 }

package/dist/assets/fonts/vite-plugin-fonts.js

@@ -49,14 +49,17 @@ function fontsPlugin({ settings, sync, logger }) {
   if (!settings.config.experimental.fonts) {
     return {
       name: "astro:fonts:fallback",
-      config() {
-        return {
-          build: {
-            rollupOptions: {
-              external: [VIRTUAL_MODULE_ID]
-            }
-          }
-        };
+      resolveId(id) {
+        if (id === VIRTUAL_MODULE_ID) {
+          return RESOLVED_VIRTUAL_MODULE_ID;
+        }
+      },
+      load(id) {
+        if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+          return {
+            code: ""
+          };
+        }
       }
     };
   }

package/dist/assets/services/service.d.ts

@@ -44,7 +44,7 @@ interface SharedServiceProps<T extends Record<string, any> = Record<string, any>
     validateOptions?: (options: ImageTransform, imageConfig: ImageConfig<T>) => ImageTransform | Promise<ImageTransform>;
 }
 export type ExternalImageService<T extends Record<string, any> = Record<string, any>> = SharedServiceProps<T>;
-export type LocalImageTransform = {
+type LocalImageTransform = {
     src: string;
     [key: string]: any;
 };

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

@@ -1,12 +1 @@
-/**
- * FNV-1a Hash implementation
- * @author Travis Webb (tjwebb) <me@traviswebb.com>
- *
- * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
- * License https://github.com/tjwebb/fnv-plus#license
- *
- * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
- * and still making use of Javascript's 53-bit integer space.
- */
-export declare const fnv1a52: (str: string) => number;
 export declare const etag: (payload: string, weak?: boolean) => string;

package/dist/assets/utils/etag.js

@@ -23,6 +23,5 @@ const etag = (payload, weak = false) => {
   return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
 };
 export {
-  etag,
-  fnv1a52
+  etag
 };

package/dist/assets/utils/vendor/image-size/lookup.d.ts

@@ -1,4 +1,3 @@
-import type { imageType } from './types/index.js';
 import type { ISizeCalculationResult } from './types/interface.ts';
 /**
  * Return size information based on an Uint8Array
@@ -7,4 +6,3 @@ import type { ISizeCalculationResult } from './types/interface.ts';
  * @returns {ISizeCalculationResult}
  */
 export declare function lookup(input: Uint8Array): ISizeCalculationResult;
-export declare const disableTypes: (types: imageType[]) => void;

package/dist/assets/utils/vendor/image-size/lookup.js

@@ -1,14 +1,8 @@
 import { typeHandlers } from "./types/index.js";
 import { detector } from "./detector.js";
-const globalOptions = {
-  disabledTypes: []
-};
 function lookup(input) {
   const type = detector(input);
   if (typeof type !== "undefined") {
-    if (globalOptions.disabledTypes.includes(type)) {
-      throw new TypeError("disabled file type: " + type);
-    }
     const size = typeHandlers.get(type).calculate(input);
     if (size !== void 0) {
       size.type = size.type ?? type;
@@ -17,10 +11,6 @@ function lookup(input) {
   }
   throw new TypeError("unsupported file type: " + type);
 }
-const disableTypes = (types) => {
-  globalOptions.disabledTypes = types;
-};
 export {
-  disableTypes,
   lookup
 };

package/dist/cli/add/index.d.ts

@@ -1,15 +1,6 @@
-import { type ProxifiedModule } from 'magicast';
 import { type Flags } from '../flags.js';
 interface AddOptions {
     flags: Flags;
 }
-interface IntegrationInfo {
-    id: string;
-    packageName: string;
-    integrationName: string;
-    dependencies: [name: string, version: string][];
-    type: 'integration' | 'adapter';
-}
 export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
-export declare function setAdapter(mod: ProxifiedModule<any>, adapter: IntegrationInfo, exportName: string): void;
 export {};

package/dist/cli/add/index.js

@@ -844,6 +844,5 @@ async function setupIntegrationConfig(opts) {
   }
 }
 export {
-  add,
-  setAdapter
+  add
 };

package/dist/cli/info/index.d.ts

@@ -8,6 +8,5 @@ export declare function getInfoOutput({ userConfig, print, }: {
     print: boolean;
 }): Promise<string>;
 export declare function printInfo({ flags }: InfoOptions): Promise<void>;
-export declare function copyToClipboard(text: string, force?: boolean): Promise<void>;
 export declare function readFromClipboard(): string;
 export {};

package/dist/cli/info/index.js

@@ -163,7 +163,6 @@ ${" ".repeat(MAX_PADDING)}${colors.green(entry)}`;
   return plaintext;
 }
 export {
-  copyToClipboard,
   getInfoOutput,
   printInfo,
   readFromClipboard

package/dist/cli/preferences/index.d.ts

@@ -2,7 +2,5 @@ import { type Flags } from '../flags.js';
 interface PreferencesOptions {
     flags: Flags;
 }
-declare const PREFERENCES_SUBCOMMANDS: readonly ["get", "set", "enable", "disable", "delete", "reset", "list"];
-export type Subcommand = (typeof PREFERENCES_SUBCOMMANDS)[number];
 export declare function preferences(subcommand: string, key: string, value: string | undefined, { flags }: PreferencesOptions): Promise<number>;
 export {};

package/dist/container/index.js

@@ -55,11 +55,6 @@ class experimental_AstroContainer {
    * @private
    */
   #withManifest = false;
-  /**
-   * Internal function responsible for importing a renderer
-   * @private
-   */
-  #getRenderer;
   constructor({
     streaming = false,
     manifest,
@@ -187,7 +182,7 @@ class experimental_AstroContainer {
     this.#pipeline.manifest.renderers[rendererIndex] = renderer;
   }
   // NOTE: we keep this private via TS instead via `#` so it's still available on the surface, so we can play with it.
-  // @ematipico: I plan to use it for a possible integration that could help people
+  // @ts-expect-error @ematipico: I plan to use it for a possible integration that could help people
   static async createFromManifest(manifest) {
     const astroConfig = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
     const container = new experimental_AstroContainer({

package/dist/content/content-layer.d.ts

@@ -2,16 +2,14 @@ import type { FSWatcher } from 'vite';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
 import type { RefreshContentOptions } from '../types/public/content.js';
-import type { LoaderContext } from './loaders/types.js';
 import type { MutableDataStore } from './mutable-data-store.js';
-export interface ContentLayerOptions {
+interface ContentLayerOptions {
     store: MutableDataStore;
     settings: AstroSettings;
     logger: Logger;
     watcher?: FSWatcher;
 }
-type CollectionLoader<TData> = () => Array<TData> | Promise<Array<TData>> | Record<string, Record<string, unknown>> | Promise<Record<string, Record<string, unknown>>>;
-export declare class ContentLayer {
+declare class ContentLayer {
     #private;
     constructor({ settings, logger, store, watcher }: ContentLayerOptions);
     /**
@@ -33,9 +31,6 @@ export declare class ContentLayer {
     sync(options?: RefreshContentOptions): Promise<void>;
     regenerateCollectionFileManifest(): Promise<void>;
 }
-export declare function simpleLoader<TData extends {
-    id: string;
-}>(handler: CollectionLoader<TData>, context: LoaderContext): Promise<void>;
 /**
  * Get the path to the data store file.
  * During development, this is in the `.astro` directory so that the Vite watcher can see it.

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.7.3") {
+    if (previousAstroVersion && previousAstroVersion !== "5.7.5") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.7.3") {
-      await this.#store.metaStore().set("astro-version", "5.7.3");
+    if ("5.7.5") {
+      await this.#store.metaStore().set("astro-version", "5.7.5");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -343,8 +343,6 @@ function contentLayerSingleton() {
 }
 const globalContentLayer = contentLayerSingleton();
 export {
-  ContentLayer,
   getDataStoreFile,
-  globalContentLayer,
-  simpleLoader
+  globalContentLayer
 };

package/dist/content/index.d.ts

@@ -1,7 +1,6 @@
-export { CONTENT_FLAG, PROPAGATED_ASSET_FLAG } from './consts.js';
 export { attachContentServerListeners } from './server-listeners.js';
 export { createContentTypesGenerator } from './types-generator.js';
-export { contentObservable, getContentPaths, hasAssetPropagationFlag } from './utils.js';
+export { getContentPaths, hasAssetPropagationFlag } from './utils.js';
 export { astroContentAssetPropagationPlugin } from './vite-plugin-content-assets.js';
 export { astroContentImportPlugin } from './vite-plugin-content-imports.js';
 export { astroContentVirtualModPlugin } from './vite-plugin-content-virtual-mod.js';

package/dist/content/index.js

@@ -1,18 +1,14 @@
-import { CONTENT_FLAG, PROPAGATED_ASSET_FLAG } from "./consts.js";
 import { attachContentServerListeners } from "./server-listeners.js";
 import { createContentTypesGenerator } from "./types-generator.js";
-import { contentObservable, getContentPaths, hasAssetPropagationFlag } from "./utils.js";
+import { getContentPaths, hasAssetPropagationFlag } from "./utils.js";
 import { astroContentAssetPropagationPlugin } from "./vite-plugin-content-assets.js";
 import { astroContentImportPlugin } from "./vite-plugin-content-imports.js";
 import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
 export {
-  CONTENT_FLAG,
-  PROPAGATED_ASSET_FLAG,
   astroContentAssetPropagationPlugin,
   astroContentImportPlugin,
   astroContentVirtualModPlugin,
   attachContentServerListeners,
-  contentObservable,
   createContentTypesGenerator,
   getContentPaths,
   hasAssetPropagationFlag

package/dist/content/loaders/file.d.ts

@@ -1,5 +1,5 @@
 import type { Loader } from './types.js';
-export interface FileOptions {
+interface FileOptions {
     /**
      * the parsing function to use for this data
      * @default JSON.parse or yaml.load, depending on the extension of the file
@@ -12,3 +12,4 @@ export interface FileOptions {
  * @param options Additional options for the file loader
  */
 export declare function file(fileName: string, options?: FileOptions): Loader;
+export {};

package/dist/content/loaders/glob.d.ts

@@ -1,5 +1,5 @@
 import type { Loader } from './types.js';
-export interface GenerateIdOptions {
+interface GenerateIdOptions {
     /** The path to the entry file, relative to the base directory. */
     entry: string;
     /** The base directory URL. */
@@ -7,7 +7,7 @@ export interface GenerateIdOptions {
     /** The parsed, unvalidated data of the entry. */
     data: Record<string, unknown>;
 }
-export interface GlobOptions {
+interface GlobOptions {
     /** The glob pattern to match files, relative to the base directory */
     pattern: string | Array<string>;
     /** The base directory to resolve the glob pattern from. Relative to the root directory, or an absolute file URL. Defaults to `.` */
@@ -28,3 +28,4 @@ export declare function glob(globOptions: GlobOptions & {
     /** @deprecated */
     _legacy?: true;
 }): Loader;
+export {};