astro 4.10.1 → 4.10.3

package/dist/@types/astro.d.ts

@@ -211,7 +211,7 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
     /**
      * The <Astro.self /> element allows a component to reference itself recursively.
      *
-     * [Astro reference](https://docs.astro.build/en/guides/api-reference/#astroself)
+     * [Astro reference](https://docs.astro.build/en/reference/api-reference/#astroself)
      */
     self: Self;
     /** Utility functions for modifying an Astro component’s slotted children
@@ -1295,7 +1295,7 @@ export interface AstroUserConfig {
          * import remarkToc from 'remark-toc';
          * {
          *   markdown: {
-         *     remarkPlugins: [remarkToc]
+         *     remarkPlugins: [ [remarkToc, { heading: "contents"} ] ]
          *   }
          * }
          * ```
@@ -1931,17 +1931,17 @@ export interface AstroUserConfig {
          *
          * ```astro
          * ---
-         * import { PUBLIC_APP_ID } from "astro:env/client"
-         * import { PUBLIC_API_URL, getSecret } from "astro:env/server"
-         * const API_TOKEN = getSecret("API_TOKEN")
+         * import { APP_ID } from "astro:env/client"
+         * import { API_URL, API_TOKEN, getSecret } from "astro:env/server"
+         * const NODE_ENV = getSecret("NODE_ENV")
          *
-         * const data = await fetch(`${PUBLIC_API_URL}/users`, {
+         * const data = await fetch(`${API_URL}/users`, {
          * 	method: "POST",
          * 	headers: {
          * 		"Content-Type": "application/json",
          * 		"Authorization": `Bearer ${API_TOKEN}`
          * 	},
-         * 	body: JSON.stringify({ appId: PUBLIC_APP_ID })
+         * 	body: JSON.stringify({ appId: APP_ID, nodeEnv: NODE_ENV })
          * })
          * ---
          * ```
@@ -1956,8 +1956,8 @@ export interface AstroUserConfig {
          *     experimental: {
          *         env: {
          *             schema: {
-         *                 PUBLIC_API_URL: envField.string({ context: "client", access: "public", optional: true }),
-         *                 PUBLIC_PORT: envField.number({ context: "server", access: "public", default: 4321 }),
+         *                 API_URL: envField.string({ context: "client", access: "public", optional: true }),
+         *                 PORT: envField.number({ context: "server", access: "public", default: 4321 }),
          *                 API_SECRET: envField.string({ context: "server", access: "secret" }),
          *             }
          *         }
@@ -1965,28 +1965,27 @@ export interface AstroUserConfig {
          * })
          * ```
          *
-         * There are currently three data types supported: strings, numbers and booleans.
+         * There are currently four data types supported: strings, numbers, booleans and enums.
          *
          * There are three kinds of environment variables, determined by the combination of `context` (client or server) and `access` (secret or public) settings defined in your [`env.schema`](#experimentalenvschema):
          *
          * - **Public client variables**: These variables end up in both your final client and server bundles, and can be accessed from both client and server through the `astro:env/client` module:
          *
          *     ```js
-         *     import { PUBLIC_API_URL } from "astro:env/client"
+         *     import { API_URL } from "astro:env/client"
          *     ```
          *
          * - **Public server variables**: These variables end up in your final server bundle and can be accessed on the server through the `astro:env/server` module:
          *
          *     ```js
-         *     import { PUBLIC_PORT } from "astro:env/server"
+         *     import { PORT } from "astro:env/server"
          *     ```
          *
-         * - **Secret server variables**: These variables are not part of your final bundle and can be accessed on the server through the `getSecret()` helper function available from the `astro:env/server` module:
+         * - **Secret server variables**: These variables are not part of your final bundle and can be accessed on the server through the `astro:env/server` module. The `getSecret()` helper function can be used to retrieve secrets not specified in the schema:
          *
          *     ```js
-         *     import { getSecret } from "astro:env/server"
+         *     import { API_SECRET, getSecret } from "astro:env/server"
          *
-         *     const API_SECRET = getSecret("API_SECRET") // typed
          *     const SECRET_NOT_IN_SCHEMA = getSecret("SECRET_NOT_IN_SCHEMA") // string | undefined
          *     ```
          *
@@ -2013,8 +2012,8 @@ export interface AstroUserConfig {
              *   experimental: {
              *     env: {
              *       schema: {
-             *         PUBLIC_API_URL: envField.string({ context: "client", access: "public", optional: true }),
-             *         PUBLIC_PORT: envField.number({ context: "server", access: "public", default: 4321 }),
+             *         API_URL: envField.string({ context: "client", access: "public", optional: true }),
+             *         PORT: envField.number({ context: "server", access: "public", default: 4321 }),
              *         API_SECRET: envField.string({ context: "server", access: "secret" }),
              *       }
              *     }
@@ -2604,7 +2603,7 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
      * }
      * ```
      *
-     * [Reference](https://docs.astro.build/en/guides/api-reference/#contextprops)
+     * [Reference](https://docs.astro.build/en/reference/api-reference/#contextprops)
      */
     props: AstroSharedContext<Props, APIParams>['props'];
     /**
@@ -2711,27 +2710,32 @@ export interface AstroRenderer {
     /** @deprecated Vite plugins should transform the JSX instead */
     jsxTransformOptions?: JSXTransformFn;
 }
-export interface SSRLoadedRenderer extends AstroRenderer {
-    ssr: {
-        check: AsyncRendererComponentFn<boolean>;
-        renderToStaticMarkup: AsyncRendererComponentFn<{
-            html: string;
-            attrs?: Record<string, string>;
-        }>;
-        supportsAstroStaticSlot?: boolean;
-        /**
-         * If provided, Astro will call this function and inject the returned
-         * script in the HTML before the first component handled by this renderer.
-         *
-         * This feature is needed by some renderers (in particular, by Solid). The
-         * Solid official hydration script sets up a page-level data structure.
-         * It is mainly used to transfer data between the server side render phase
-         * and the browser application state. Solid Components rendered later in
-         * the HTML may inject tiny scripts into the HTML that call into this
-         * page-level data structure.
-         */
-        renderHydrationScript?: () => string;
-    };
+export interface NamedSSRLoadedRendererValue extends SSRLoadedRendererValue {
+    name: string;
+}
+export interface SSRLoadedRendererValue {
+    name?: string;
+    check: AsyncRendererComponentFn<boolean>;
+    renderToStaticMarkup: AsyncRendererComponentFn<{
+        html: string;
+        attrs?: Record<string, string>;
+    }>;
+    supportsAstroStaticSlot?: boolean;
+    /**
+     * If provided, Astro will call this function and inject the returned
+     * script in the HTML before the first component handled by this renderer.
+     *
+     * This feature is needed by some renderers (in particular, by Solid). The
+     * Solid official hydration script sets up a page-level data structure.
+     * It is mainly used to transfer data between the server side render phase
+     * and the browser application state. Solid Components rendered later in
+     * the HTML may inject tiny scripts into the HTML that call into this
+     * page-level data structure.
+     */
+    renderHydrationScript?: () => string;
+}
+export interface SSRLoadedRenderer extends Pick<AstroRenderer, 'name' | 'clientEntrypoint'> {
+    ssr: SSRLoadedRendererValue;
 }
 export type HookParameters<Hook extends keyof AstroIntegration['hooks'], Fn = AstroIntegration['hooks'][Hook]> = Fn extends (...args: any) => any ? Parameters<Fn>[0] : never;
 export interface AstroIntegration {

package/dist/config/index.d.ts

@@ -1,7 +1,7 @@
-import type { UserConfig } from 'vite';
+import type { UserConfig as ViteUserConfig } from 'vite';
 import type { AstroInlineConfig, AstroUserConfig } from '../@types/astro.js';
 export declare function defineConfig(config: AstroUserConfig): AstroUserConfig;
-export declare function getViteConfig(inlineConfig: UserConfig, inlineAstroConfig?: AstroInlineConfig): ({ mode, command }: {
+export declare function getViteConfig(userViteConfig: ViteUserConfig, inlineAstroConfig?: AstroInlineConfig): ({ mode, command }: {
     mode: string;
     command: 'serve' | 'build';
 }) => Promise<Record<string, any>>;

package/dist/config/index.js

@@ -2,7 +2,7 @@ import { Logger } from "../core/logger/core.js";
 function defineConfig(config) {
   return config;
 }
-function getViteConfig(inlineConfig, inlineAstroConfig = {}) {
+function getViteConfig(userViteConfig, inlineAstroConfig = {}) {
   return async ({ mode, command }) => {
     const cmd = command === "serve" ? "dev" : command;
     const [
@@ -26,8 +26,8 @@ function getViteConfig(inlineConfig, inlineAstroConfig = {}) {
       dest: nodeLogDestination,
       level: "info"
     });
-    const { astroConfig: config, userConfig } = await resolveConfig(inlineAstroConfig, cmd);
-    let settings = await createSettings(config, inlineConfig.root);
+    const { astroConfig: config } = await resolveConfig(inlineAstroConfig, cmd);
+    let settings = await createSettings(config, userViteConfig.root);
     settings = await runHookConfigSetup({ settings, command: cmd, logger });
     const viteConfig = await createVite(
       {
@@ -40,7 +40,7 @@ function getViteConfig(inlineConfig, inlineAstroConfig = {}) {
       { settings, logger, mode }
     );
     await runHookConfigDone({ settings, logger });
-    return mergeConfig(viteConfig, userConfig);
+    return mergeConfig(viteConfig, userViteConfig);
   };
 }
 export {

package/dist/container/index.d.ts

@@ -1,4 +1,4 @@
-import type { AstroUserConfig, Props, RouteType, SSRLoadedRenderer, SSRManifest, SSRResult } from '../@types/astro.js';
+import type { AstroUserConfig, NamedSSRLoadedRendererValue, Props, RouteType, SSRLoadedRenderer, SSRLoadedRendererValue, SSRManifest, SSRResult } from '../@types/astro.js';
 import type { AstroComponentFactory } from '../runtime/server/index.js';
 /**
  * Options to be passed when rendering a route
@@ -59,6 +59,13 @@ export type ContainerRenderOptions = {
      */
     props?: Props;
 };
+export type AddServerRenderer = {
+    renderer: NamedSSRLoadedRendererValue;
+    name: never;
+} | {
+    renderer: SSRLoadedRendererValue;
+    name: string;
+};
 export type AstroContainerUserConfig = Omit<AstroUserConfig, 'integrations' | 'adapter'>;
 /**
  * Options that are used for the entire lifecycle of the current instance of the container.
@@ -122,6 +129,30 @@ export declare class experimental_AstroContainer {
      * @param {AstroContainerOptions=} containerOptions
      */
     static create(containerOptions?: AstroContainerOptions): Promise<experimental_AstroContainer>;
+    /**
+     * Use this function to manually add a renderer to the container.
+     *
+     * This function is preferred when you require to use the container with a renderer in environments such as on-demand pages.
+     *
+     * ## Example
+     *
+     * ```js
+     * import reactRenderer from "@astrojs/react/server.js";
+     * import vueRenderer from "@astrojs/vue/server.js";
+     * import customRenderer from "../renderer/customRenderer.js";
+     * import { experimental_AstroContainer as AstroContainer } from "astro/container"
+     *
+     * const container = await AstroContainer.create();
+     * container.addServerRenderer(reactRenderer);
+     * container.addServerRenderer(vueRenderer);
+     * container.addServerRenderer("customRenderer", customRenderer);
+     * ```
+     *
+     * @param options {object}
+     * @param options.name The name of the renderer. The name **isn't** arbitrary, and it should match the name of the package.
+     * @param options.renderer The server renderer exported by integration.
+     */
+    addServerRenderer(options: AddServerRenderer): void;
     private static createFromManifest;
     /**
      * @description

package/dist/container/index.js

@@ -93,6 +93,48 @@ class experimental_AstroContainer {
       resolve
     });
   }
+  /**
+   * Use this function to manually add a renderer to the container.
+   *
+   * This function is preferred when you require to use the container with a renderer in environments such as on-demand pages.
+   *
+   * ## Example
+   *
+   * ```js
+   * import reactRenderer from "@astrojs/react/server.js";
+   * import vueRenderer from "@astrojs/vue/server.js";
+   * import customRenderer from "../renderer/customRenderer.js";
+   * import { experimental_AstroContainer as AstroContainer } from "astro/container"
+   *
+   * const container = await AstroContainer.create();
+   * container.addServerRenderer(reactRenderer);
+   * container.addServerRenderer(vueRenderer);
+   * container.addServerRenderer("customRenderer", customRenderer);
+   * ```
+   *
+   * @param options {object}
+   * @param options.name The name of the renderer. The name **isn't** arbitrary, and it should match the name of the package.
+   * @param options.renderer The server renderer exported by integration.
+   */
+  addServerRenderer(options) {
+    const { renderer, name } = options;
+    if (!renderer.check || !renderer.renderToStaticMarkup) {
+      throw new Error(
+        "The renderer you passed isn't valid. A renderer is usually an object that exposes the `check` and `renderToStaticMarkup` functions.\nUsually, the renderer is exported by a /server.js entrypoint e.g. `import renderer from '@astrojs/react/server.js'`"
+      );
+    }
+    if (isNamedRenderer(renderer)) {
+      this.#pipeline.manifest.renderers.push({
+        name: renderer.name,
+        ssr: renderer
+      });
+    } else {
+      this.#pipeline.manifest.renderers.push({
+        name,
+        ssr: 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
   static async createFromManifest(manifest) {
@@ -234,6 +276,9 @@ class experimental_AstroContainer {
     return { default: componentFactory };
   }
 }
+function isNamedRenderer(renderer) {
+  return !!renderer?.name;
+}
 export {
   experimental_AstroContainer
 };

package/dist/container/pipeline.d.ts

@@ -5,7 +5,7 @@ export declare class ContainerPipeline extends Pipeline {
     static create({ logger, manifest, renderers, resolve, serverLike, streaming, }: Pick<ContainerPipeline, 'logger' | 'manifest' | 'renderers' | 'resolve' | 'serverLike' | 'streaming'>): ContainerPipeline;
     componentMetadata(_routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
-    tryRewrite(rewritePayload: RewritePayload): Promise<[RouteData, ComponentInstance]>;
+    tryRewrite(payload: RewritePayload, request: Request): Promise<[RouteData, ComponentInstance, URL]>;
     insertRoute(route: RouteData, componentInstance: ComponentInstance): void;
     getComponentByRoute(_routeData: RouteData): Promise<ComponentInstance>;
     rewriteKnownRoute(pathname: string, _sourceRoute: RouteData): ComponentInstance;

package/dist/container/pipeline.js

@@ -5,7 +5,7 @@ import {
   createModuleScriptElement,
   createStylesheetElementSet
 } from "../core/render/ssr-element.js";
-import { default404Page } from "../core/routing/astro-designed-error-pages.js";
+import { DEFAULT_404_ROUTE, default404Page } from "../core/routing/astro-designed-error-pages.js";
 class ContainerPipeline extends Pipeline {
   /**
    * Internal cache to store components instances by `RouteData`.
@@ -51,29 +51,28 @@ class ContainerPipeline extends Pipeline {
     }
     return { links, styles, scripts };
   }
-  async tryRewrite(rewritePayload) {
+  async tryRewrite(payload, request) {
     let foundRoute;
+    let finalUrl = void 0;
     for (const route of this.manifest.routes) {
-      const routeData = route.routeData;
-      if (rewritePayload instanceof URL) {
-        if (routeData.pattern.test(rewritePayload.pathname)) {
-          foundRoute = routeData;
-          break;
-        }
-      } else if (rewritePayload instanceof Request) {
-        const url = new URL(rewritePayload.url);
-        if (routeData.pattern.test(url.pathname)) {
-          foundRoute = routeData;
-          break;
-        }
-      } else if (routeData.pattern.test(decodeURI(rewritePayload))) {
-        foundRoute = routeData;
+      if (payload instanceof URL) {
+        finalUrl = payload;
+      } else if (payload instanceof Request) {
+        finalUrl = new URL(payload.url);
+      } else {
+        finalUrl = new URL(payload, new URL(request.url).origin);
+      }
+      if (route.routeData.pattern.test(decodeURI(finalUrl.pathname))) {
+        foundRoute = route.routeData;
+        break;
+      } else if (finalUrl.pathname === "/404") {
+        foundRoute = DEFAULT_404_ROUTE;
         break;
       }
     }
-    if (foundRoute) {
+    if (foundRoute && finalUrl) {
       const componentInstance = await this.getComponentByRoute(foundRoute);
-      return [foundRoute, componentInstance];
+      return [foundRoute, componentInstance, finalUrl];
     } else {
       throw new AstroError(RouteNotFound);
     }

package/dist/container/vite-plugin-container.d.ts

@@ -0,0 +1,2 @@
+import type * as vite from 'vite';
+export default function astroContainer(): vite.Plugin;

package/dist/container/vite-plugin-container.js

@@ -0,0 +1,15 @@
+const virtualModuleId = "astro:container";
+function astroContainer() {
+  return {
+    name: "astro:container",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === virtualModuleId) {
+        return this.resolve("astro/virtual-modules/container.js");
+      }
+    }
+  };
+}
+export {
+  astroContainer as default
+};

package/dist/content/runtime.js

@@ -55,7 +55,7 @@ function createGetCollection({
     );
     let entries = [];
     if (!import.meta.env?.DEV && cacheEntriesByCollection.has(collection)) {
-      entries = [...cacheEntriesByCollection.get(collection)];
+      entries = cacheEntriesByCollection.get(collection);
     } else {
       const limit = pLimit(10);
       entries = await Promise.all(
@@ -88,7 +88,7 @@ function createGetCollection({
     if (typeof filter === "function") {
       return entries.filter(filter);
     } else {
-      return entries;
+      return entries.slice();
     }
   };
 }

package/dist/content/types-generator.js

@@ -72,16 +72,14 @@ async function createContentTypesGenerator({
       if (!isCollectionEvent) return { shouldGenerateTypes: false };
       switch (event.name) {
         case "addDir":
-          collectionEntryMap[JSON.stringify(collection2)] = {
+          collectionEntryMap[collectionKey2] = {
             type: "unknown",
             entries: {}
           };
           logger.debug("content", `${cyan(collection2)} collection added`);
           break;
         case "unlinkDir":
-          if (collectionKey2 in collectionEntryMap) {
-            delete collectionEntryMap[JSON.stringify(collection2)];
-          }
+          delete collectionEntryMap[collectionKey2];
           break;
       }
       return { shouldGenerateTypes: true };
@@ -354,36 +352,36 @@ async function writeContentFiles({
   data: ${dataType}
 };
 `;
-          if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
-            let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
-            if (zodSchemaForJson instanceof z.ZodObject) {
-              zodSchemaForJson = zodSchemaForJson.extend({
-                $schema: z.string().optional()
-              });
-            }
-            try {
-              await fs.promises.writeFile(
-                new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
-                JSON.stringify(
-                  zodToJsonSchema(zodSchemaForJson, {
-                    name: collectionKey.replace(/"/g, ""),
-                    markdownDescription: true,
-                    errorMessages: true
-                  }),
-                  null,
-                  2
-                )
-              );
-            } catch (err) {
-              logger.warn(
-                "content",
-                `An error was encountered while creating the JSON schema for the ${entryKey} entry in ${collectionKey} collection. Proceeding without it. Error: ${err}`
-              );
-            }
+          dataTypesStr += `};
+`;
+        }
+        if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
+          let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
+          if (zodSchemaForJson instanceof z.ZodObject) {
+            zodSchemaForJson = zodSchemaForJson.extend({
+              $schema: z.string().optional()
+            });
+          }
+          try {
+            await fs.promises.writeFile(
+              new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
+              JSON.stringify(
+                zodToJsonSchema(zodSchemaForJson, {
+                  name: collectionKey.replace(/"/g, ""),
+                  markdownDescription: true,
+                  errorMessages: true
+                }),
+                null,
+                2
+              )
+            );
+          } catch (err) {
+            logger.warn(
+              "content",
+              `An error was encountered while creating the JSON schema for the ${collectionKey} collection. Proceeding without it. Error: ${err}`
+            );
           }
         }
-        dataTypesStr += `};
-`;
         break;
     }
   }

package/dist/content/utils.d.ts

@@ -5,6 +5,7 @@ import type { PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings, ContentEntryType, DataEntryType } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
 import { CONTENT_FLAGS } from './consts.js';
 /**
  * Amap from a collection + slug to the local file path.
@@ -99,6 +100,16 @@ export declare function getEntryData(entry: {
 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>;
+export declare function getSymlinkedContentCollections({ contentDir, logger, fs, }: {
+    contentDir: URL;
+    logger: Logger;
+    fs: typeof fsMod;
+}): Promise<Map<string, string>>;
+export declare function reverseSymlink({ entry, symlinks, contentDir, }: {
+    entry: string | URL;
+    contentDir: string | URL;
+    symlinks?: Map<string, string>;
+}): string;
 export declare function getEntryCollectionName({ contentDir, entry, }: Pick<ContentPaths, 'contentDir'> & {
     entry: string | URL;
 }): string | undefined;

package/dist/content/utils.js

@@ -108,6 +108,53 @@ function getEntryConfigByExtMap(entryTypes) {
   }
   return map;
 }
+async function getSymlinkedContentCollections({
+  contentDir,
+  logger,
+  fs
+}) {
+  const contentPaths = /* @__PURE__ */ new Map();
+  const contentDirPath = fileURLToPath(contentDir);
+  try {
+    if (!fs.existsSync(contentDirPath) || !fs.lstatSync(contentDirPath).isDirectory()) {
+      return contentPaths;
+    }
+  } catch {
+    return contentPaths;
+  }
+  try {
+    const contentDirEntries = await fs.promises.readdir(contentDir, { withFileTypes: true });
+    for (const entry of contentDirEntries) {
+      if (entry.isSymbolicLink()) {
+        const entryPath = path.join(contentDirPath, entry.name);
+        const realPath = await fs.promises.realpath(entryPath);
+        contentPaths.set(normalizePath(realPath), entry.name);
+      }
+    }
+  } catch (e) {
+    logger.warn("content", `Error when reading content directory "${contentDir}"`);
+    logger.debug("content", e);
+    return /* @__PURE__ */ new Map();
+  }
+  return contentPaths;
+}
+function reverseSymlink({
+  entry,
+  symlinks,
+  contentDir
+}) {
+  const entryPath = normalizePath(typeof entry === "string" ? entry : fileURLToPath(entry));
+  const contentDirPath = typeof contentDir === "string" ? contentDir : fileURLToPath(contentDir);
+  if (!symlinks || symlinks.size === 0) {
+    return entryPath;
+  }
+  for (const [realPath, symlinkName] of symlinks) {
+    if (entryPath.startsWith(realPath)) {
+      return normalizePath(path.join(contentDirPath, symlinkName, entryPath.replace(realPath, "")));
+    }
+  }
+  return entryPath;
+}
 function getEntryCollectionName({
   contentDir,
   entry
@@ -354,6 +401,7 @@ export {
   getEntrySlug,
   getEntryType,
   getExtGlob,
+  getSymlinkedContentCollections,
   globalContentConfigObserver,
   hasAnyContentFlag,
   hasAssetPropagationFlag,
@@ -363,5 +411,6 @@ export {
   msg,
   parseEntrySlug,
   reloadContentConfigObserver,
+  reverseSymlink,
   safeParseFrontmatter
 };

package/dist/content/vite-plugin-content-imports.d.ts

@@ -2,7 +2,9 @@
 import type fsMod from 'node:fs';
 import type { Plugin } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
-export declare function astroContentImportPlugin({ fs, settings, }: {
+import type { Logger } from '../core/logger/core.js';
+export declare function astroContentImportPlugin({ fs, settings, logger, }: {
     fs: typeof fsMod;
     settings: AstroSettings;
+    logger: Logger;
 }): Plugin[];