astro 4.11.6 → 4.12.0

package/dist/core/routing/astro-designed-error-pages.js

@@ -44,9 +44,12 @@ async function default404Page({ pathname }) {
   );
 }
 default404Page.isAstroComponentFactory = true;
+const default404Instance = {
+  default: default404Page
+};
 export {
   DEFAULT_404_ROUTE,
   DEFAULT_500_ROUTE,
-  default404Page,
+  default404Instance,
   ensure404Route
 };

package/dist/core/routing/default.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentInstance, ManifestData, SSRManifest } from '../../@types/astro.js';
+export declare function injectDefaultRoutes(ssrManifest: SSRManifest, routeManifest: ManifestData): ManifestData;
+type DefaultRouteParams = {
+    instance: ComponentInstance;
+    matchesComponent(filePath: URL): boolean;
+    route: string;
+    component: string;
+};
+export declare function createDefaultRoutes(manifest: SSRManifest): DefaultRouteParams[];
+export {};

package/dist/core/routing/default.js

@@ -0,0 +1,38 @@
+import { DEFAULT_404_COMPONENT } from "../constants.js";
+import {
+  SERVER_ISLAND_COMPONENT,
+  SERVER_ISLAND_ROUTE,
+  createEndpoint as createServerIslandEndpoint,
+  ensureServerIslandRoute
+} from "../server-islands/endpoint.js";
+import {
+  DEFAULT_404_ROUTE,
+  default404Instance,
+  ensure404Route
+} from "./astro-designed-error-pages.js";
+function injectDefaultRoutes(ssrManifest, routeManifest) {
+  ensure404Route(routeManifest);
+  ensureServerIslandRoute(ssrManifest, routeManifest);
+  return routeManifest;
+}
+function createDefaultRoutes(manifest) {
+  const root = new URL(manifest.hrefRoot);
+  return [
+    {
+      instance: default404Instance,
+      matchesComponent: (filePath) => filePath.href === new URL(DEFAULT_404_COMPONENT, root).href,
+      route: DEFAULT_404_ROUTE.route,
+      component: DEFAULT_404_COMPONENT
+    },
+    {
+      instance: createServerIslandEndpoint(manifest),
+      matchesComponent: (filePath) => filePath.href === new URL(SERVER_ISLAND_COMPONENT, root).href,
+      route: SERVER_ISLAND_ROUTE,
+      component: SERVER_ISLAND_COMPONENT
+    }
+  ];
+}
+export {
+  createDefaultRoutes,
+  injectDefaultRoutes
+};

package/dist/core/routing/manifest/create.d.ts

@@ -1,8 +1,7 @@
-import type { AstroConfig, AstroSettings, ManifestData, RoutePart } from '../../../@types/astro.js';
+import type { AstroSettings, ManifestData, RoutePart } from '../../../@types/astro.js';
 import type { Logger } from '../../logger/core.js';
 import nodeFs from 'node:fs';
 export declare function getParts(part: string, file: string): RoutePart[];
-export declare function getPattern(segments: RoutePart[][], base: AstroConfig['base'], addTrailingSlash: AstroConfig['trailingSlash']): RegExp;
 export declare function validateSegment(segment: string, file?: string): void;
 export interface CreateRouteManifestParams {
     /** Astro Settings object */

package/dist/core/routing/manifest/create.js

@@ -12,6 +12,7 @@ import { removeLeadingForwardSlash, slash } from "../../path.js";
 import { resolvePages } from "../../util.js";
 import { routeComparator } from "../priority.js";
 import { getRouteGenerator } from "./generator.js";
+import { getPattern } from "./pattern.js";
 const require2 = createRequire(import.meta.url);
 function countOccurrences(needle, haystack) {
   let count = 0;
@@ -39,38 +40,6 @@ function getParts(part, file) {
   });
   return result;
 }
-function getPattern(segments, base, addTrailingSlash) {
-  const pathname = segments.map((segment) => {
-    if (segment.length === 1 && segment[0].spread) {
-      return "(?:\\/(.*?))?";
-    } else {
-      return "\\/" + segment.map((part) => {
-        if (part.spread) {
-          return "(.*?)";
-        } else if (part.dynamic) {
-          return "([^/]+?)";
-        } else {
-          return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        }
-      }).join("");
-    }
-  }).join("");
-  const trailing = addTrailingSlash && segments.length ? getTrailingSlashPattern(addTrailingSlash) : "$";
-  let initial = "\\/";
-  if (addTrailingSlash === "never" && base !== "/") {
-    initial = "";
-  }
-  return new RegExp(`^${pathname || initial}${trailing}`);
-}
-function getTrailingSlashPattern(addTrailingSlash) {
-  if (addTrailingSlash === "always") {
-    return "\\/$";
-  }
-  if (addTrailingSlash === "never") {
-    return "$";
-  }
-  return "\\/?$";
-}
 function validateSegment(segment, file = "") {
   if (!file) file = segment;
   if (/\]\[/.test(segment)) {
@@ -314,7 +283,7 @@ function createRedirectRoutes({ settings }, routeMap, logger) {
 function isStaticSegment(segment) {
   return segment.every((part) => !part.dynamic && !part.spread);
 }
-function detectRouteCollision(a, b, config, logger) {
+function detectRouteCollision(a, b, _config, logger) {
   if (a.type === "fallback" || b.type === "fallback") {
     return;
   }
@@ -535,6 +504,5 @@ function joinSegments(segments) {
 export {
   createRouteManifest,
   getParts,
-  getPattern,
   validateSegment
 };

package/dist/core/routing/manifest/pattern.d.ts

@@ -0,0 +1,2 @@
+import type { AstroConfig, RoutePart } from '../../../@types/astro.js';
+export declare function getPattern(segments: RoutePart[][], base: AstroConfig['base'], addTrailingSlash: AstroConfig['trailingSlash']): RegExp;

package/dist/core/routing/manifest/pattern.js

@@ -0,0 +1,35 @@
+function getPattern(segments, base, addTrailingSlash) {
+  const pathname = segments.map((segment) => {
+    if (segment.length === 1 && segment[0].spread) {
+      return "(?:\\/(.*?))?";
+    } else {
+      return "\\/" + segment.map((part) => {
+        if (part.spread) {
+          return "(.*?)";
+        } else if (part.dynamic) {
+          return "([^/]+?)";
+        } else {
+          return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+      }).join("");
+    }
+  }).join("");
+  const trailing = addTrailingSlash && segments.length ? getTrailingSlashPattern(addTrailingSlash) : "$";
+  let initial = "\\/";
+  if (addTrailingSlash === "never" && base !== "/") {
+    initial = "";
+  }
+  return new RegExp(`^${pathname || initial}${trailing}`);
+}
+function getTrailingSlashPattern(addTrailingSlash) {
+  if (addTrailingSlash === "always") {
+    return "\\/$";
+  }
+  if (addTrailingSlash === "never") {
+    return "$";
+  }
+  return "\\/?$";
+}
+export {
+  getPattern
+};

package/dist/core/server-islands/endpoint.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentInstance, ManifestData, RouteData, SSRManifest } from '../../@types/astro.js';
+export declare const SERVER_ISLAND_ROUTE = "/_server-islands/[name]";
+export declare const SERVER_ISLAND_COMPONENT = "_server-islands.astro";
+type ConfigFields = Pick<SSRManifest, 'base' | 'trailingSlash'>;
+export declare function getServerIslandRouteData(config: ConfigFields): RouteData;
+export declare function ensureServerIslandRoute(config: ConfigFields, routeManifest: ManifestData): void;
+export declare function createEndpoint(manifest: SSRManifest): ComponentInstance;
+export {};

package/dist/core/server-islands/endpoint.js

@@ -0,0 +1,76 @@
+import {
+  renderComponent,
+  renderTemplate
+} from "../../runtime/server/index.js";
+import { createSlotValueFromString } from "../../runtime/server/render/slot.js";
+import { getPattern } from "../routing/manifest/pattern.js";
+const SERVER_ISLAND_ROUTE = "/_server-islands/[name]";
+const SERVER_ISLAND_COMPONENT = "_server-islands.astro";
+function getServerIslandRouteData(config) {
+  const segments = [
+    [{ content: "_server-islands", dynamic: false, spread: false }],
+    [{ content: "name", dynamic: true, spread: false }]
+  ];
+  const route = {
+    type: "page",
+    component: SERVER_ISLAND_COMPONENT,
+    generate: () => "",
+    params: ["name"],
+    segments,
+    pattern: getPattern(segments, config.base, config.trailingSlash),
+    prerender: false,
+    isIndex: false,
+    fallbackRoutes: [],
+    route: SERVER_ISLAND_ROUTE
+  };
+  return route;
+}
+function ensureServerIslandRoute(config, routeManifest) {
+  if (routeManifest.routes.some((route) => route.route === "/_server-islands/[name]")) {
+    return;
+  }
+  routeManifest.routes.push(getServerIslandRouteData(config));
+}
+function createEndpoint(manifest) {
+  const page = async (result) => {
+    const params = result.params;
+    const request = result.request;
+    const raw = await request.text();
+    const data = JSON.parse(raw);
+    if (!params.name) {
+      return new Response(null, {
+        status: 400,
+        statusText: "Bad request"
+      });
+    }
+    const componentId = params.name;
+    const imp = manifest.serverIslandMap?.get(componentId);
+    if (!imp) {
+      return new Response(null, {
+        status: 404,
+        statusText: "Not found"
+      });
+    }
+    const props = data.props;
+    const componentModule = await imp();
+    const Component = componentModule[data.componentExport];
+    const slots = {};
+    for (const prop in data.slots) {
+      slots[prop] = createSlotValueFromString(data.slots[prop]);
+    }
+    return renderTemplate`${renderComponent(result, "Component", Component, props, slots)}`;
+  };
+  page.isAstroComponentFactory = true;
+  const instance = {
+    default: page,
+    partial: true
+  };
+  return instance;
+}
+export {
+  SERVER_ISLAND_COMPONENT,
+  SERVER_ISLAND_ROUTE,
+  createEndpoint,
+  ensureServerIslandRoute,
+  getServerIslandRouteData
+};

package/dist/core/server-islands/vite-plugin-server-islands.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../@types/astro.js';
+export declare const VIRTUAL_ISLAND_MAP_ID = "@astro-server-islands";
+export declare const RESOLVED_VIRTUAL_ISLAND_MAP_ID: string;
+export declare function vitePluginServerIslands({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;

package/dist/core/server-islands/vite-plugin-server-islands.js

@@ -0,0 +1,82 @@
+const VIRTUAL_ISLAND_MAP_ID = "@astro-server-islands";
+const RESOLVED_VIRTUAL_ISLAND_MAP_ID = "\0" + VIRTUAL_ISLAND_MAP_ID;
+const serverIslandPlaceholder = "'$$server-islands$$'";
+function vitePluginServerIslands({ settings }) {
+  let command = "serve";
+  let viteServer = null;
+  const referenceIdMap = /* @__PURE__ */ new Map();
+  return {
+    name: "astro:server-islands",
+    enforce: "post",
+    config(_config, { command: _command }) {
+      command = _command;
+    },
+    configureServer(_server) {
+      viteServer = _server;
+    },
+    resolveId(name) {
+      if (name === VIRTUAL_ISLAND_MAP_ID) {
+        return RESOLVED_VIRTUAL_ISLAND_MAP_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_ISLAND_MAP_ID) {
+        return `export const serverIslandMap = ${serverIslandPlaceholder};`;
+      }
+    },
+    transform(_code, id) {
+      if (id.endsWith(".astro")) {
+        const info = this.getModuleInfo(id);
+        if (info?.meta) {
+          const astro = info.meta.astro;
+          if (astro?.serverComponents.length) {
+            for (const comp of astro.serverComponents) {
+              if (!settings.serverIslandNameMap.has(comp.resolvedPath)) {
+                let name = comp.localName;
+                let idx = 1;
+                while (true) {
+                  if (!settings.serverIslandMap.has(name)) {
+                    break;
+                  }
+                  name += idx++;
+                }
+                settings.serverIslandNameMap.set(comp.resolvedPath, name);
+                settings.serverIslandMap.set(name, () => {
+                  return viteServer?.ssrLoadModule(comp.resolvedPath);
+                });
+                if (command === "build") {
+                  let referenceId = this.emitFile({
+                    type: "chunk",
+                    id: comp.specifier,
+                    importer: id,
+                    name: comp.localName
+                  });
+                  referenceIdMap.set(comp.resolvedPath, referenceId);
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    renderChunk(code) {
+      if (code.includes(serverIslandPlaceholder)) {
+        let mapSource = "new Map([";
+        for (let [resolvedPath, referenceId] of referenceIdMap) {
+          const fileName = this.getFileName(referenceId);
+          const islandName = settings.serverIslandNameMap.get(resolvedPath);
+          mapSource += `
+	['${islandName}', () => import('./${fileName}')],`;
+        }
+        mapSource += "\n]);";
+        referenceIdMap.clear();
+        return code.replace(serverIslandPlaceholder, mapSource);
+      }
+    }
+  };
+}
+export {
+  RESOLVED_VIRTUAL_ISLAND_MAP_ID,
+  VIRTUAL_ISLAND_MAP_ID,
+  vitePluginServerIslands
+};

package/dist/core/sync/index.d.ts

@@ -1,14 +1,22 @@
-import type { AstroInlineConfig } from '../../@types/astro.js';
+import fsMod from 'node:fs';
+import type { AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
 import type { Logger } from '../logger/core.js';
-export type ProcessExit = 0 | 1;
-export type SyncOptions = {};
-export type SyncInternalOptions = SyncOptions & {
+export type SyncOptions = {
     logger: Logger;
+    settings: AstroSettings;
+    skip?: {
+        content?: boolean;
+    };
 };
+export default function sync({ inlineConfig, fs, telemetry: _telemetry, }: {
+    inlineConfig: AstroInlineConfig;
+    fs?: typeof fsMod;
+    telemetry?: boolean;
+}): Promise<void>;
 /**
  * Generates TypeScript types for all Astro modules. This sets up a `src/env.d.ts` file for type inferencing,
  * and defines the `astro:content` module for the Content Collections API.
  *
  * @experimental The JavaScript API is experimental
  */
-export default function sync(inlineConfig: AstroInlineConfig, options?: SyncOptions): Promise<ProcessExit>;
+export declare function syncInternal({ logger, fs, settings, skip, }: SyncOptions): Promise<void>;

package/dist/core/sync/index.js

@@ -10,7 +10,6 @@ import { syncAstroEnv } from "../../env/sync.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
 import { runHookConfigSetup } from "../../integrations/hooks.js";
-import { setUpEnvTs } from "../../vite-plugin-inject-env-ts/index.js";
 import { getTimeStat } from "../build/util.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
@@ -26,41 +25,58 @@ import {
 } from "../errors/index.js";
 import { formatErrorMessage } from "../messages.js";
 import { ensureProcessNodeEnv } from "../util.js";
-async function sync(inlineConfig, options) {
+import { setUpEnvTs } from "./setup-env-ts.js";
+async function sync({
+  inlineConfig,
+  fs,
+  telemetry: _telemetry = false
+}) {
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
-  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
-  telemetry.record(eventCliSession("sync", userConfig));
-  const _settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
-  const settings = await runHookConfigSetup({
-    settings: _settings,
-    logger,
-    command: "build"
+  const { astroConfig, userConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
+  if (_telemetry) {
+    telemetry.record(eventCliSession("sync", userConfig));
+  }
+  let settings = await createSettings(astroConfig, inlineConfig.root);
+  settings = await runHookConfigSetup({
+    command: "build",
+    settings,
+    logger
   });
+  return await syncInternal({ settings, logger, fs });
+}
+async function syncInternal({
+  logger,
+  fs = fsMod,
+  settings,
+  skip
+}) {
+  const cwd = fileURLToPath(settings.config.root);
   const timerStart = performance.now();
   const dbPackage = await getPackage(
     "@astrojs/db",
     logger,
     {
       optional: true,
-      cwd: inlineConfig.root
+      cwd
     },
     []
   );
   try {
-    await dbPackage?.typegen?.(astroConfig);
-    const exitCode = await syncContentCollections(settings, { ...options, logger });
-    if (exitCode !== 0) return exitCode;
-    syncAstroEnv(settings, options?.fs);
-    logger.info(null, `Types generated ${dim(getTimeStat(timerStart, performance.now()))}`);
-    return 0;
+    await dbPackage?.typegen?.(settings.config);
+    if (!skip?.content) {
+      await syncContentCollections(settings, { fs, logger });
+    }
+    syncAstroEnv(settings, fs);
+    await setUpEnvTs({ settings, logger, fs });
+    logger.info("types", `Generated ${dim(getTimeStat(timerStart, performance.now()))}`);
   } catch (err) {
     const error = createSafeError(err);
     logger.error(
-      "content",
+      "types",
       formatErrorMessage(collectErrorMetadata(error), logger.level() === "debug") + "\n"
     );
-    return 1;
+    throw error;
   }
 }
 async function syncContentCollections(settings, { logger, fs }) {
@@ -86,7 +102,7 @@ async function syncContentCollections(settings, { logger, fs }) {
     const contentTypesGenerator = await createContentTypesGenerator({
       contentConfigObserver: globalContentConfigObserver,
       logger,
-      fs: fs ?? fsMod,
+      fs,
       settings,
       viteServer: tempViteServer
     });
@@ -100,7 +116,6 @@ async function syncContentCollections(settings, { logger, fs }) {
         case "no-content-dir":
         default:
           logger.debug("types", "No content directory found. Skipping type generation.");
-          return 0;
       }
     }
   } catch (e) {
@@ -120,10 +135,8 @@ async function syncContentCollections(settings, { logger, fs }) {
   } finally {
     await tempViteServer.close();
   }
-  await setUpEnvTs({ settings, logger, fs: fs ?? fsMod });
-  return 0;
 }
 export {
   sync as default,
-  syncContentCollections
+  syncInternal
 };

package/dist/core/sync/setup-env-ts.d.ts

@@ -0,0 +1,8 @@
+import type fsMod from 'node:fs';
+import type { AstroSettings } from '../../@types/astro.js';
+import { type Logger } from '../logger/core.js';
+export declare function setUpEnvTs({ settings, logger, fs, }: {
+    settings: AstroSettings;
+    logger: Logger;
+    fs: typeof fsMod;
+}): Promise<void>;

package/dist/{vite-plugin-inject-env-ts/index.js → core/sync/setup-env-ts.js}

@@ -2,28 +2,10 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { bold } from "kleur/colors";
 import { normalizePath } from "vite";
-import { ACTIONS_TYPES_FILE } from "../actions/consts.js";
-import { CONTENT_TYPES_FILE } from "../content/consts.js";
-import {} from "../core/logger/core.js";
-import { ENV_TYPES_FILE } from "../env/constants.js";
-function getEnvTsPath({ srcDir }) {
-  return new URL("env.d.ts", srcDir);
-}
-function astroInjectEnvTsPlugin({
-  settings,
-  logger,
-  fs
-}) {
-  return {
-    name: "astro-inject-env-ts",
-    // Use `post` to ensure project setup is complete
-    // Ex. `.astro` types have been written
-    enforce: "post",
-    async config() {
-      await setUpEnvTs({ settings, logger, fs });
-    }
-  };
-}
+import { ACTIONS_TYPES_FILE } from "../../actions/consts.js";
+import { CONTENT_TYPES_FILE } from "../../content/consts.js";
+import { ENV_TYPES_FILE } from "../../env/constants.js";
+import {} from "../logger/core.js";
 function getDotAstroTypeReference({
   settings,
   filename
@@ -41,7 +23,7 @@ async function setUpEnvTs({
   logger,
   fs
 }) {
-  const envTsPath = getEnvTsPath(settings.config);
+  const envTsPath = new URL("env.d.ts", settings.config.srcDir);
   const envTsPathRelativetoRoot = normalizePath(
     path.relative(fileURLToPath(settings.config.root), fileURLToPath(envTsPath))
   );
@@ -61,7 +43,8 @@ async function setUpEnvTs({
     });
   }
   if (fs.existsSync(envTsPath)) {
-    let typesEnvContents = await fs.promises.readFile(envTsPath, "utf-8");
+    const initialEnvContents = await fs.promises.readFile(envTsPath, "utf-8");
+    let typesEnvContents = initialEnvContents;
     for (const injectedType of injectedTypes) {
       if (!injectedType.meetsCondition || await injectedType.meetsCondition?.()) {
         const expectedTypeReference = getDotAstroTypeReference({
@@ -74,8 +57,10 @@ ${typesEnvContents}`;
         }
       }
     }
-    logger.info("types", `Added ${bold(envTsPathRelativetoRoot)} type declarations.`);
-    await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
+    if (initialEnvContents !== typesEnvContents) {
+      logger.info("types", `Updated ${bold(envTsPathRelativetoRoot)} type declarations.`);
+      await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
+    }
   } else {
     let referenceDefs = [];
     referenceDefs.push('/// <reference types="astro/client" />');
@@ -90,7 +75,5 @@ ${typesEnvContents}`;
   }
 }
 export {
-  astroInjectEnvTsPlugin,
-  getEnvTsPath,
   setUpEnvTs
 };

package/dist/env/errors.d.ts

@@ -0,0 +1,7 @@
+import type { ValidationResultErrors } from './validators.js';
+export interface InvalidVariable {
+    key: string;
+    type: string;
+    errors: ValidationResultErrors;
+}
+export declare function invalidVariablesToError(invalid: Array<InvalidVariable>): string[];

package/dist/env/errors.js

@@ -0,0 +1,16 @@
+function invalidVariablesToError(invalid) {
+  const _errors = [];
+  for (const { key, type, errors } of invalid) {
+    if (errors[0] === "missing") {
+      _errors.push(`${key} is missing`);
+    } else if (errors[0] === "type") {
+      _errors.push(`${key}'s type is invalid, expected: ${type}`);
+    } else {
+      _errors.push(`The following constraints for ${key} are not met: ${errors.join(", ")}`);
+    }
+  }
+  return _errors;
+}
+export {
+  invalidVariablesToError
+};

package/dist/env/runtime.d.ts

@@ -1,8 +1,9 @@
-import { AstroError, AstroErrorData } from '../core/errors/index.js';
-export { validateEnvVariable } from './validators.js';
+import { AstroError } from '../core/errors/index.js';
+import type { ValidationResultInvalid } from './validators.js';
+export { validateEnvVariable, getEnvFieldType } from './validators.js';
 export type GetEnv = (key: string) => string | undefined;
 export declare function setGetEnv(fn: GetEnv, reset?: boolean): void;
 declare let _onSetGetEnv: (reset: boolean) => void;
 export declare function setOnSetGetEnv(fn: typeof _onSetGetEnv): void;
 export declare function getEnv(...args: Parameters<GetEnv>): string | undefined;
-export declare function createInvalidVariableError(...args: Parameters<typeof AstroErrorData.EnvInvalidVariable.message>): AstroError;
+export declare function createInvalidVariablesError(key: string, type: string, result: ValidationResultInvalid): AstroError;

package/dist/env/runtime.js

@@ -1,5 +1,6 @@
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { validateEnvVariable } from "./validators.js";
+import { invalidVariablesToError } from "./errors.js";
+import { validateEnvVariable, getEnvFieldType } from "./validators.js";
 let _getEnv = (key) => process.env[key];
 function setGetEnv(fn, reset = false) {
   _getEnv = fn;
@@ -13,15 +14,18 @@ function setOnSetGetEnv(fn) {
 function getEnv(...args) {
   return _getEnv(...args);
 }
-function createInvalidVariableError(...args) {
+function createInvalidVariablesError(key, type, result) {
   return new AstroError({
-    ...AstroErrorData.EnvInvalidVariable,
-    message: AstroErrorData.EnvInvalidVariable.message(...args)
+    ...AstroErrorData.EnvInvalidVariables,
+    message: AstroErrorData.EnvInvalidVariables.message(
+      invalidVariablesToError([{ key, type, errors: result.errors }])
+    )
   });
 }
 export {
-  createInvalidVariableError,
+  createInvalidVariablesError,
   getEnv,
+  getEnvFieldType,
   setGetEnv,
   setOnSetGetEnv,
   validateEnvVariable

package/dist/env/validators.d.ts

@@ -1,13 +1,15 @@
 import type { EnvFieldType } from './schema.js';
 export type ValidationResultValue = EnvFieldType['default'];
 export type ValidationResultErrors = ['missing'] | ['type'] | Array<string>;
-type ValidationResult = {
+interface ValidationResultValid {
     ok: true;
     value: ValidationResultValue;
-} | {
+}
+export interface ValidationResultInvalid {
     ok: false;
     errors: ValidationResultErrors;
-};
+}
+type ValidationResult = ValidationResultValid | ValidationResultInvalid;
 export declare function getEnvFieldType(options: EnvFieldType): string;
 export declare function validateEnvVariable(value: string | undefined, options: EnvFieldType): ValidationResult;
 export {};