astro 4.13.4 → 4.14.0

package/dist/content/utils.d.ts

@@ -37,6 +37,126 @@ declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
 }, {
     type: "data";
     schema?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"content_layer">;
+    schema: z.ZodOptional<z.ZodAny>;
+    loader: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">>, "many">, z.ZodPromise<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">>, "many">>]>>, z.ZodObject<{
+        name: z.ZodString;
+        load: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+            collection: z.ZodString;
+            store: z.ZodAny;
+            meta: z.ZodAny;
+            logger: z.ZodAny;
+            settings: z.ZodAny;
+            parseData: z.ZodAny;
+            generateDigest: z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>;
+            watcher: z.ZodOptional<z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            settings?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            parseData?: any;
+            watcher?: any;
+        }, {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            settings?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            parseData?: any;
+            watcher?: any;
+        }>], null>, z.ZodUnknown>;
+        schema: z.ZodOptional<z.ZodAny>;
+        render: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            settings?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    }, {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            settings?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    type: "content_layer";
+    loader: ((...args: unknown[]) => z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | Promise<z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[]>) | {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            settings?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    };
+    schema?: any;
+}, {
+    type: "content_layer";
+    loader: ((...args: unknown[]) => z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | Promise<z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[]>) | {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            settings?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    };
+    schema?: any;
 }>]>;
 declare const contentConfigParser: z.ZodObject<{
     collections: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
@@ -57,6 +177,126 @@ declare const contentConfigParser: z.ZodObject<{
     }, {
         type: "data";
         schema?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"content_layer">;
+        schema: z.ZodOptional<z.ZodAny>;
+        loader: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">>, "many">, z.ZodPromise<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">>, "many">>]>>, z.ZodObject<{
+            name: z.ZodString;
+            load: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+                collection: z.ZodString;
+                store: z.ZodAny;
+                meta: z.ZodAny;
+                logger: z.ZodAny;
+                settings: z.ZodAny;
+                parseData: z.ZodAny;
+                generateDigest: z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>;
+                watcher: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }, {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }>], null>, z.ZodUnknown>;
+            schema: z.ZodOptional<z.ZodAny>;
+            render: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        }, {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
+    }, {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
     }>]>>;
 }, "strip", z.ZodTypeAny, {
     collections: Record<string, {
@@ -65,6 +305,28 @@ declare const contentConfigParser: z.ZodObject<{
     } | {
         type: "data";
         schema?: any;
+    } | {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
     }>;
 }, {
     collections: Record<string, {
@@ -73,10 +335,34 @@ declare const contentConfigParser: z.ZodObject<{
     } | {
         type: "data";
         schema?: any;
+    } | {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                settings?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
     }>;
 }>;
 export type CollectionConfig = z.infer<typeof collectionConfigParser>;
-export type ContentConfig = z.infer<typeof contentConfigParser>;
+export type ContentConfig = z.infer<typeof contentConfigParser> & {
+    digest?: string;
+};
 type EntryInternal = {
     rawData: string | undefined;
     filePath: string;
@@ -87,12 +373,21 @@ export declare function parseEntrySlug({ id, collection, generatedSlug, frontmat
     generatedSlug: string;
     frontmatterSlug?: unknown;
 }): string;
+export declare function getEntryDataAndImages<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends TInputData = TInputData>(entry: {
+    id: string;
+    collection: string;
+    unvalidatedData: TInputData;
+    _internal: EntryInternal;
+}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<{
+    data: TOutputData;
+    imageImports: Array<string>;
+}>;
 export declare function getEntryData(entry: {
     id: string;
     collection: string;
     unvalidatedData: Record<string, unknown>;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext: PluginContext): Promise<Record<string, unknown>>;
+}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<Record<string, unknown>>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
 export declare function getDataEntryExts(settings: Pick<AstroSettings, 'dataEntryTypes'>): string[];
 export declare function getEntryConfigByExtMap<TEntryType extends ContentEntryType | DataEntryType>(entryTypes: TEntryType[]): Map<string, TEntryType>;
@@ -130,6 +425,7 @@ export declare function safeParseFrontmatter(source: string, id?: string): matte
 export declare const globalContentConfigObserver: ContentObservable;
 export declare function hasAnyContentFlag(viteId: string): boolean;
 export declare function hasContentFlag(viteId: string, flag: (typeof CONTENT_FLAGS)[number]): boolean;
+export declare function isDeferredModule(viteId: string): boolean;
 export declare function reloadContentConfigObserver({ observer, ...loadContentConfigOpts }: {
     fs: typeof fsMod;
     settings: AstroSettings;
@@ -181,4 +477,12 @@ export declare function getEntrySlug({ id, collection, generatedSlug, contentEnt
 }): Promise<string>;
 export declare function getExtGlob(exts: string[]): string;
 export declare function hasAssetPropagationFlag(id: string): boolean;
+/**
+ * Convert a platform path to a posix path.
+ */
+export declare function posixifyPath(filePath: string): string;
+/**
+ * Unlike `path.posix.relative`, this function will accept a platform path and return a posix path.
+ */
+export declare function posixRelative(from: string, to: string): string;
 export {};

package/dist/content/utils.js

@@ -4,10 +4,17 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { slug as githubSlug } from "github-slugger";
 import matter from "gray-matter";
 import { normalizePath } from "vite";
+import xxhash from "xxhash-wasm";
 import { z } from "zod";
 import { AstroError, AstroErrorData, MarkdownError, errorMap } from "../core/errors/index.js";
 import { isYAMLException } from "../core/errors/utils.js";
-import { CONTENT_FLAGS, PROPAGATED_ASSET_FLAG } from "./consts.js";
+import {
+  CONTENT_FLAGS,
+  CONTENT_LAYER_TYPE,
+  CONTENT_MODULE_FLAG,
+  IMAGE_IMPORT_PREFIX,
+  PROPAGATED_ASSET_FLAG
+} from "./consts.js";
 import { createImage } from "./runtime-assets.js";
 const collectionConfigParser = z.union([
   z.object({
@@ -17,6 +24,50 @@ const collectionConfigParser = z.union([
   z.object({
     type: z.literal("data"),
     schema: z.any().optional()
+  }),
+  z.object({
+    type: z.literal(CONTENT_LAYER_TYPE),
+    schema: z.any().optional(),
+    loader: z.union([
+      z.function().returns(
+        z.union([
+          z.array(
+            z.object({
+              id: z.string()
+            }).catchall(z.unknown())
+          ),
+          z.promise(
+            z.array(
+              z.object({
+                id: z.string()
+              }).catchall(z.unknown())
+            )
+          )
+        ])
+      ),
+      z.object({
+        name: z.string(),
+        load: z.function(
+          z.tuple(
+            [
+              z.object({
+                collection: z.string(),
+                store: z.any(),
+                meta: z.any(),
+                logger: z.any(),
+                settings: z.any(),
+                parseData: z.any(),
+                generateDigest: z.function(z.tuple([z.any()], z.string())),
+                watcher: z.any().optional()
+              })
+            ],
+            z.unknown()
+          )
+        ),
+        schema: z.any().optional(),
+        render: z.function(z.tuple([z.any()], z.unknown())).optional()
+      })
+    ])
   })
 ]);
 const contentConfigParser = z.object({
@@ -37,19 +88,29 @@ function parseEntrySlug({
     });
   }
 }
-async function getEntryData(entry, collectionConfig, shouldEmitFile, pluginContext) {
+async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, pluginContext) {
   let data;
-  if (collectionConfig.type === "data") {
+  if (collectionConfig.type === "data" || collectionConfig.type === CONTENT_LAYER_TYPE) {
     data = entry.unvalidatedData;
   } else {
     const { slug, ...unvalidatedData } = entry.unvalidatedData;
     data = unvalidatedData;
   }
   let schema = collectionConfig.schema;
+  const imageImports = /* @__PURE__ */ new Set();
   if (typeof schema === "function") {
-    schema = schema({
-      image: createImage(pluginContext, shouldEmitFile, entry._internal.filePath)
-    });
+    if (pluginContext) {
+      schema = schema({
+        image: createImage(pluginContext, shouldEmitFile, entry._internal.filePath)
+      });
+    } else if (collectionConfig.type === CONTENT_LAYER_TYPE) {
+      schema = schema({
+        image: () => z.string().transform((val) => {
+          imageImports.add(val);
+          return `${IMAGE_IMPORT_PREFIX}${val}`;
+        })
+      });
+    }
   }
   if (schema) {
     if (collectionConfig.type === "content" && typeof schema === "object" && "shape" in schema && schema.shape.slug) {
@@ -88,6 +149,15 @@ async function getEntryData(entry, collectionConfig, shouldEmitFile, pluginConte
       throw formattedError;
     }
   }
+  return { data, imageImports: Array.from(imageImports) };
+}
+async function getEntryData(entry, collectionConfig, shouldEmitFile, pluginContext) {
+  const { data } = await getEntryDataAndImages(
+    entry,
+    collectionConfig,
+    shouldEmitFile,
+    pluginContext
+  );
   return data;
 }
 function getContentEntryExts(settings) {
@@ -268,6 +338,10 @@ function hasContentFlag(viteId, flag) {
   const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
   return flags.has(flag);
 }
+function isDeferredModule(viteId) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  return flags.has(CONTENT_MODULE_FLAG);
+}
 async function loadContentConfig({
   fs,
   settings,
@@ -282,7 +356,9 @@ async function loadContentConfig({
   unparsedConfig = await viteServer.ssrLoadModule(configPathname);
   const config = contentConfigParser.safeParse(unparsedConfig);
   if (config.success) {
-    return config.data;
+    const hasher = await xxhash();
+    const digest = await hasher.h64ToString(await fs.promises.readFile(configPathname, "utf-8"));
+    return { ...config.data, digest };
   } else {
     return void 0;
   }
@@ -383,6 +459,12 @@ function hasAssetPropagationFlag(id) {
     return false;
   }
 }
+function posixifyPath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+function posixRelative(from, to) {
+  return posixifyPath(path.relative(from, to));
+}
 export {
   contentObservable,
   getContentEntryExts,
@@ -393,6 +475,7 @@ export {
   getEntryCollectionName,
   getEntryConfigByExtMap,
   getEntryData,
+  getEntryDataAndImages,
   getEntrySlug,
   getEntryType,
   getExtGlob,
@@ -401,7 +484,10 @@ export {
   hasAnyContentFlag,
   hasAssetPropagationFlag,
   hasContentFlag,
+  isDeferredModule,
   parseEntrySlug,
+  posixRelative,
+  posixifyPath,
   reloadContentConfigObserver,
   reverseSymlink,
   safeParseFrontmatter

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

@@ -1,11 +1,12 @@
 import { extname } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
 import { joinPaths, prependForwardSlash } from "../core/path.js";
 import { getStylesForURL } from "../vite-plugin-astro-server/css.js";
 import { getScriptsForURL } from "../vite-plugin-astro-server/scripts.js";
 import {
+  CONTENT_IMAGE_FLAG,
   CONTENT_RENDER_FLAG,
   LINKS_PLACEHOLDER,
   PROPAGATED_ASSET_FLAG,
@@ -22,6 +23,13 @@ function astroContentAssetPropagationPlugin({
     name: "astro:content-asset-propagation",
     enforce: "pre",
     async resolveId(id, importer, opts) {
+      if (hasContentFlag(id, CONTENT_IMAGE_FLAG)) {
+        const [base, query] = id.split("?");
+        const params = new URLSearchParams(query);
+        const importerParam = params.get("importer");
+        const importerPath = importerParam ? fileURLToPath(new URL(importerParam, settings.config.root)) : importer;
+        return this.resolve(base, importerPath, { skipSelf: true, ...opts });
+      }
       if (hasContentFlag(id, CONTENT_RENDER_FLAG)) {
         const base = id.split("?")[0];
         for (const { extensions, handlePropagation = true } of settings.contentEntryTypes) {