astro 4.10.2 → 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/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/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/types-generator.js

@@ -352,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[];

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

@@ -16,10 +16,12 @@ import {
   getEntryConfigByExtMap,
   getEntryData,
   getEntryType,
+  getSymlinkedContentCollections,
   globalContentConfigObserver,
   hasContentFlag,
   parseEntrySlug,
-  reloadContentConfigObserver
+  reloadContentConfigObserver,
+  reverseSymlink
 } from "./utils.js";
 function getContentRendererByViteId(viteId, settings) {
   let ext = viteId.split(".").pop();
@@ -35,7 +37,8 @@ const CHOKIDAR_MODIFIED_EVENTS = ["add", "unlink", "change"];
 const COLLECTION_TYPES_TO_INVALIDATE_ON = ["data", "content", "config"];
 function astroContentImportPlugin({
   fs,
-  settings
+  settings,
+  logger
 }) {
   const contentPaths = getContentPaths(settings.config, fs);
   const contentEntryExts = getContentEntryExts(settings);
@@ -44,15 +47,23 @@ function astroContentImportPlugin({
   const dataEntryConfigByExt = getEntryConfigByExtMap(settings.dataEntryTypes);
   const { contentDir } = contentPaths;
   let shouldEmitFile = false;
+  let symlinks;
   const plugins = [
     {
       name: "astro:content-imports",
       config(_config, env) {
         shouldEmitFile = env.command === "build";
       },
+      async buildStart() {
+        symlinks = await getSymlinkedContentCollections({ contentDir, logger, fs });
+      },
       async transform(_, viteId) {
         if (hasContentFlag(viteId, DATA_FLAG)) {
-          const fileId = viteId.split("?")[0] ?? viteId;
+          const fileId = reverseSymlink({
+            entry: viteId.split("?")[0] ?? viteId,
+            contentDir,
+            symlinks
+          });
           const { id, data, collection, _internal } = await getDataEntryModule({
             fileId,
             entryConfigByExt: dataEntryConfigByExt,
@@ -74,7 +85,7 @@ export const _internal = {
 `;
           return code;
         } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
-          const fileId = viteId.split("?")[0];
+          const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
           const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
             fileId,
             entryConfigByExt: contentEntryConfigByExt,

package/dist/core/base-pipeline.js

@@ -30,7 +30,7 @@ class Pipeline {
     if (callSetGetEnv && manifest.experimentalEnvGetSecretEnabled) {
       setGetEnv(() => {
         throw new AstroError(AstroErrorData.EnvUnsupportedGetSecret);
-      });
+      }, true);
     }
   }
   internalMiddleware;

package/dist/core/build/internal.d.ts

@@ -89,6 +89,10 @@ export interface BuildInternals {
     ssrSplitEntryChunks: Map<string, Rollup.OutputChunk>;
     componentMetadata: SSRResult['componentMetadata'];
     middlewareEntryPoint?: URL;
+    /**
+     * Chunks in the bundle that are only used in prerendering that we can delete later
+     */
+    prerenderOnlyChunks: Rollup.OutputChunk[];
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/internal.js

@@ -26,7 +26,8 @@ function createBuildInternals() {
     componentMetadata: /* @__PURE__ */ new Map(),
     ssrSplitEntryChunks: /* @__PURE__ */ new Map(),
     entryPoints: /* @__PURE__ */ new Map(),
-    cacheManifestUsed: false
+    cacheManifestUsed: false,
+    prerenderOnlyChunks: []
   };
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {

package/dist/core/build/page-data.js

@@ -29,8 +29,7 @@ async function collectPagesData(opts) {
         route,
         moduleSpecifier: "",
         styles: [],
-        hoistedScript: void 0,
-        hasSharedModules: false
+        hoistedScript: void 0
       };
       clearInterval(routeCollectionLogTimeout);
       if (settings.config.output === "static") {
@@ -50,8 +49,7 @@ async function collectPagesData(opts) {
       route,
       moduleSpecifier: "",
       styles: [],
-      hoistedScript: void 0,
-      hasSharedModules: false
+      hoistedScript: void 0
     };
   }
   clearInterval(dataCollectionLogTimeout);

package/dist/core/build/plugins/plugin-chunks.js

@@ -8,6 +8,12 @@ function vitePluginChunks() {
           if (id.includes("astro/dist/runtime/server/")) {
             return "astro/server";
           }
+          if (id.includes("astro/dist/runtime")) {
+            return "astro";
+          }
+          if (id.includes("astro/dist/env/setup")) {
+            return "astro/env-setup";
+          }
         }
       });
     }