astro 5.15.3 → 6.0.0-alpha.0

package/dist/core/routing/validation.js

@@ -1,5 +1,5 @@
 import { AstroError, AstroErrorData } from "../errors/index.js";
-const VALID_PARAM_TYPES = ["string", "number", "undefined"];
+const VALID_PARAM_TYPES = ["string", "undefined"];
 function validateGetStaticPathsParameter([key, value], route) {
   if (!VALID_PARAM_TYPES.includes(typeof value)) {
     throw new AstroError({
@@ -22,7 +22,7 @@ function validateDynamicRouteModule(mod, {
     });
   }
 }
-function validateGetStaticPathsResult(result, logger, route) {
+function validateGetStaticPathsResult(result, route) {
   if (!Array.isArray(result)) {
     throw new AstroError({
       ...AstroErrorData.InvalidGetStaticPathsReturn,
@@ -49,22 +49,6 @@ function validateGetStaticPathsResult(result, logger, route) {
         }
       });
     }
-    for (const [key, val] of Object.entries(pathObject.params)) {
-      if (!(typeof val === "undefined" || typeof val === "string" || typeof val === "number")) {
-        logger.warn(
-          "router",
-          `getStaticPaths() returned an invalid path param: "${key}". A string, number or undefined value was expected, but got \`${JSON.stringify(
-            val
-          )}\`.`
-        );
-      }
-      if (typeof val === "string" && val === "") {
-        logger.warn(
-          "router",
-          `getStaticPaths() returned an invalid path param: "${key}". \`undefined\` expected for an optional param, but got empty string.`
-        );
-      }
-    }
   });
 }
 export {

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

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

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

@@ -125,6 +125,5 @@ export {
   SERVER_ISLAND_COMPONENT,
   SERVER_ISLAND_ROUTE,
   createEndpoint,
-  getServerIslandRouteData,
   injectServerIslandRoute
 };

package/dist/core/sync/index.js

@@ -117,8 +117,7 @@ async function syncInternal({
     settings.timer.end("Sync content layer");
   } else {
     const paths = getContentPaths(settings.config, fs);
-    if (paths.config.exists || paths.liveConfig.exists || // Legacy collections don't require a config file
-    settings.config.legacy?.collections && fs.existsSync(paths.contentDir)) {
+    if (paths.config.exists || paths.liveConfig.exists) {
       settings.injectedTypes.push({
         filename: CONTENT_TYPES_FILE
       });
@@ -187,18 +186,11 @@ async function syncContentCollections(settings, {
       settings,
       viteServer: tempViteServer
     });
-    const typesResult = await contentTypesGenerator.init();
+    await contentTypesGenerator.init();
     const contentConfig = globalContentConfigObserver.get();
     if (contentConfig.status === "error") {
       throw contentConfig.error;
     }
-    if (typesResult.typesGenerated === false) {
-      switch (typesResult.reason) {
-        case "no-content-dir":
-        default:
-          logger.debug("types", "No content directory found. Skipping type generation.");
-      }
-    }
   } catch (e) {
     const safeError = createSafeError(e);
     if (isAstroError(e)) {

package/dist/env/env-loader.d.ts

@@ -2,7 +2,6 @@ import type { AstroConfig } from '../types/public/index.js';
 interface EnvLoaderOptions {
     mode: string;
     config: AstroConfig;
-    useStatic: boolean;
 }
 export declare const createEnvLoader: (options: EnvLoaderOptions) => {
     get: () => Record<string, string>;

package/dist/env/env-loader.js

@@ -3,8 +3,7 @@ import { loadEnv } from "vite";
 const isValidIdentifierRe = /^[_$a-zA-Z][\w$]*$/;
 function getPrivateEnv({
   fullEnv,
-  viteConfig,
-  useStatic
+  viteConfig
 }) {
   let envPrefixes = ["PUBLIC_"];
   if (viteConfig.envPrefix) {
@@ -15,25 +14,13 @@ function getPrivateEnv({
     if (!isValidIdentifierRe.test(key) || envPrefixes.some((prefix) => key.startsWith(prefix))) {
       continue;
     }
-    if (!useStatic && typeof process.env[key] !== "undefined") {
-      let value = process.env[key];
-      if (typeof value !== "string") {
-        value = `${value}`;
-      }
-      if (value === "0" || value === "1" || value === "true" || value === "false") {
-        privateEnv[key] = value;
-      } else {
-        privateEnv[key] = `process.env.${key}`;
-      }
-    } else {
-      privateEnv[key] = JSON.stringify(fullEnv[key]);
-    }
+    privateEnv[key] = JSON.stringify(fullEnv[key]);
   }
   return privateEnv;
 }
-function getEnv({ mode, config, useStatic }) {
+function getEnv({ mode, config }) {
   const loaded = loadEnv(mode, config.vite.envDir ?? fileURLToPath(config.root), "");
-  const privateEnv = getPrivateEnv({ fullEnv: loaded, viteConfig: config.vite, useStatic });
+  const privateEnv = getPrivateEnv({ fullEnv: loaded, viteConfig: config.vite });
   return { loaded, privateEnv };
 }
 const createEnvLoader = (options) => {

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

@@ -13,42 +13,13 @@ import { invalidVariablesToError } from "./errors.js";
 import { getEnvFieldType, validateEnvVariable } from "./validators.js";
 function astroEnv({ settings, sync, envLoader }) {
   const { schema, validateSecrets } = settings.config.env;
-  let isDev;
-  let templates = null;
-  function ensureTemplateAreLoaded() {
-    if (templates !== null) {
-      return;
-    }
-    const loadedEnv = envLoader.get();
-    if (!isDev) {
-      for (const [key, value] of Object.entries(loadedEnv)) {
-        if (value !== void 0) {
-          process.env[key] = value;
-        }
-      }
-    }
-    const validatedVariables = validatePublicVariables({
-      schema,
-      loadedEnv,
-      validateSecrets,
-      sync
-    });
-    templates = {
-      ...getTemplates(schema, validatedVariables, isDev ? loadedEnv : null),
-      internal: `export const schema = ${JSON.stringify(schema)};`
-    };
-  }
+  let isBuild;
+  let populated = false;
   return {
     name: "astro-env-plugin",
     enforce: "pre",
     config(_, { command }) {
-      isDev = command !== "build";
-    },
-    buildStart() {
-      ensureTemplateAreLoaded();
-    },
-    buildEnd() {
-      templates = null;
+      isBuild = command === "build";
     },
     resolveId(id) {
       if (id === CLIENT_VIRTUAL_MODULE_ID) {
@@ -62,23 +33,43 @@ function astroEnv({ settings, sync, envLoader }) {
       }
     },
     load(id, options) {
-      if (id === RESOLVED_CLIENT_VIRTUAL_MODULE_ID) {
-        ensureTemplateAreLoaded();
-        return { code: templates.client };
+      if (id === RESOLVED_INTERNAL_VIRTUAL_MODULE_ID) {
+        return { code: `export const schema = ${JSON.stringify(schema)};` };
       }
-      if (id === RESOLVED_SERVER_VIRTUAL_MODULE_ID) {
-        if (options?.ssr) {
-          ensureTemplateAreLoaded();
-          return { code: templates.server };
-        }
+      if (id === RESOLVED_SERVER_VIRTUAL_MODULE_ID && !options?.ssr) {
         throw new AstroError({
           ...AstroErrorData.ServerOnlyModule,
           message: AstroErrorData.ServerOnlyModule.message(SERVER_VIRTUAL_MODULE_ID)
         });
       }
-      if (id === RESOLVED_INTERNAL_VIRTUAL_MODULE_ID) {
-        ensureTemplateAreLoaded();
-        return { code: templates.internal };
+      if (id === RESOLVED_CLIENT_VIRTUAL_MODULE_ID || id === RESOLVED_SERVER_VIRTUAL_MODULE_ID) {
+        const loadedEnv = envLoader.get();
+        if (isBuild && !populated) {
+          for (const [key, value] of Object.entries(loadedEnv)) {
+            if (value !== void 0) {
+              process.env[key] = value;
+            }
+          }
+          populated = true;
+        }
+        const validatedVariables = validatePublicVariables({
+          schema,
+          loadedEnv,
+          validateSecrets,
+          sync
+        });
+        const { client, server } = getTemplates({
+          schema,
+          validatedVariables,
+          // In dev, we inline process.env to avoid freezing it
+          loadedEnv: isBuild ? null : loadedEnv
+        });
+        if (id === RESOLVED_CLIENT_VIRTUAL_MODULE_ID) {
+          return { code: client };
+        }
+        if (id === RESOLVED_SERVER_VIRTUAL_MODULE_ID) {
+          return { code: server };
+        }
       }
     }
   };
@@ -112,9 +103,14 @@ function validatePublicVariables({
   }
   return valid;
 }
-function getTemplates(schema, validatedVariables, loadedEnv) {
+let cachedServerTemplate;
+function getTemplates({
+  schema,
+  validatedVariables,
+  loadedEnv
+}) {
   let client = "";
-  let server = readFileSync(MODULE_TEMPLATE_URL, "utf-8");
+  let server = cachedServerTemplate ??= readFileSync(MODULE_TEMPLATE_URL, "utf-8");
   let onSetGetEnv = "";
   for (const { key, value, context } of validatedVariables) {
     const str = `export const ${key} = ${JSON.stringify(value)};`;

package/dist/i18n/index.js

@@ -251,9 +251,6 @@ function redirectToFallback({
         if (pathFallbackLocale === defaultLocale && strategy === "pathname-prefix-other-locales") {
           if (context.url.pathname.includes(`${base}`)) {
             newPathname = context.url.pathname.replace(`/${urlLocale}`, ``);
-            if (newPathname === "") {
-              newPathname = "/";
-            }
           } else {
             newPathname = context.url.pathname.replace(`/${urlLocale}`, `/`);
           }

package/dist/integrations/hooks.d.ts

@@ -80,10 +80,9 @@ type RunHookBuildSsr = {
     config: AstroConfig;
     manifest: SerializedSSRManifest;
     logger: Logger;
-    entryPoints: Map<RouteData, URL>;
     middlewareEntryPoint: URL | undefined;
 };
-export declare function runHookBuildSsr({ config, manifest, logger, entryPoints, middlewareEntryPoint, }: RunHookBuildSsr): Promise<void>;
+export declare function runHookBuildSsr({ config, manifest, logger, middlewareEntryPoint, }: RunHookBuildSsr): Promise<void>;
 export declare function runHookBuildGenerated({ settings, logger, experimentalRouteToHeaders, }: {
     settings: AstroSettings;
     logger: Logger;

package/dist/integrations/hooks.js

@@ -261,9 +261,6 @@ async function runHookConfigSetup({
   if (astroJSXRenderer) {
     updatedSettings.renderers.push(astroJSXRenderer);
   }
-  if (updatedConfig.i18n && typeof updatedConfig.i18n.routing !== "string") {
-    updatedConfig.i18n.routing.redirectToDefaultLocale ??= updatedConfig.i18n.routing.prefixDefaultLocale || false;
-  }
   updatedSettings.config = updatedConfig;
   return updatedSettings;
 }
@@ -415,13 +412,8 @@ async function runHookBuildSsr({
   config,
   manifest,
   logger,
-  entryPoints,
   middlewareEntryPoint
 }) {
-  const entryPointsMap = /* @__PURE__ */ new Map();
-  for (const [key, value] of entryPoints) {
-    entryPointsMap.set(toIntegrationRouteData(key), value);
-  }
   for (const integration of config.integrations) {
     await runHookInternal({
       integration,
@@ -429,7 +421,6 @@ async function runHookBuildSsr({
       logger,
       params: () => ({
         manifest,
-        entryPoints: entryPointsMap,
         middlewareEntryPoint
       })
     });
@@ -453,7 +444,6 @@ async function runHookBuildGenerated({
 async function runHookBuildDone({ settings, pages, routes, logger }) {
   const dir = getClientOutputDirectory(settings);
   await fsMod.promises.mkdir(dir, { recursive: true });
-  const integrationRoutes = routes.map(toIntegrationRouteData);
   for (const integration of settings.config.integrations) {
     await runHookInternal({
       integration,
@@ -462,7 +452,6 @@ async function runHookBuildDone({ settings, pages, routes, logger }) {
       params: () => ({
         pages: pages.map((p) => ({ pathname: p })),
         dir,
-        routes: integrationRoutes,
         assets: new Map(
           routes.filter((r) => r.distURL !== void 0).map((r) => [r.route, r.distURL])
         )
@@ -528,22 +517,6 @@ function toIntegrationResolvedRoute(route) {
     redirectRoute: route.redirectRoute ? toIntegrationResolvedRoute(route.redirectRoute) : void 0
   };
 }
-function toIntegrationRouteData(route) {
-  return {
-    route: route.route,
-    component: route.component,
-    generate: route.generate,
-    params: route.params,
-    pathname: route.pathname,
-    segments: route.segments,
-    prerender: route.prerender,
-    redirect: route.redirect,
-    redirectRoute: route.redirectRoute ? toIntegrationRouteData(route.redirectRoute) : void 0,
-    type: route.type,
-    pattern: route.pattern,
-    distURL: route.distURL
-  };
-}
 export {
   getToolbarServerCommunicationHelpers,
   normalizeCodegenDir,

package/dist/prefetch/index.d.ts

@@ -9,16 +9,6 @@ interface InitOptions {
  */
 export declare function init(defaultOpts?: InitOptions): void;
 export interface PrefetchOptions {
-    /**
-     * How the prefetch should prioritize the URL. (default `'link'`)
-     * - `'link'`: use `<link rel="prefetch">`.
-     * - `'fetch'`: use `fetch()`.
-     *
-     * @deprecated It is recommended to not use this option, and let prefetch use `'link'` whenever it's supported,
-     * or otherwise fall back to `'fetch'`. `'link'` works better if the URL doesn't set an appropriate cache header,
-     * as the browser will continue to cache it as long as it's used subsequently.
-     */
-    with?: 'link' | 'fetch';
     /**
      * Should prefetch even on data saver mode or slow connection. (default `false`)
      */

package/dist/prefetch/index.js

@@ -127,7 +127,7 @@ function prefetch(url, opts) {
   if (clientPrerender && HTMLScriptElement.supports?.("speculationrules")) {
     debug?.(`[astro] Prefetching ${url} with <script type="speculationrules">`);
     appendSpeculationRules(url, opts?.eagerness ?? "immediate");
-  } else if (document.createElement("link").relList?.supports?.("prefetch") && opts?.with !== "fetch") {
+  } else if (document.createElement("link").relList?.supports?.("prefetch")) {
     debug?.(`[astro] Prefetching ${url} with <link rel="prefetch">`);
     const link = document.createElement("link");
     link.rel = "prefetch";

package/dist/runtime/server/astro-global.d.ts

@@ -1,2 +1,2 @@
-import type { AstroGlobalPartial } from '../../types/public/context.js';
-export declare function createAstro(site: string | undefined): AstroGlobalPartial;
+import type { AstroGlobal } from '../../types/public/context.js';
+export declare function createAstro(site: string | undefined): AstroGlobal;

package/dist/runtime/server/astro-global.js

@@ -1,31 +1,93 @@
-import { ASTRO_VERSION } from "../../core/constants.js";
+import { ASTRO_GENERATOR } from "../../core/constants.js";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-function createAstroGlobFn() {
-  const globHandler = (importMetaGlobResult) => {
-    console.warn(`Astro.glob is deprecated and will be removed in a future major version of Astro.
-Use import.meta.glob instead: https://vitejs.dev/guide/features.html#glob-import`);
-    if (typeof importMetaGlobResult === "string") {
-      throw new AstroError({
-        ...AstroErrorData.AstroGlobUsedOutside,
-        message: AstroErrorData.AstroGlobUsedOutside.message(JSON.stringify(importMetaGlobResult))
-      });
-    }
-    let allEntries = [...Object.values(importMetaGlobResult)];
-    if (allEntries.length === 0) {
-      throw new AstroError({
-        ...AstroErrorData.AstroGlobNoMatch,
-        message: AstroErrorData.AstroGlobNoMatch.message(JSON.stringify(importMetaGlobResult))
-      });
-    }
-    return Promise.all(allEntries.map((fn) => fn()));
-  };
-  return globHandler;
+function createError(name) {
+  return new AstroError({
+    ...AstroErrorData.UnavailableAstroGlobal,
+    message: AstroErrorData.UnavailableAstroGlobal.message(name)
+  });
 }
 function createAstro(site) {
   return {
-    site: site ? new URL(site) : void 0,
-    generator: `Astro v${ASTRO_VERSION}`,
-    glob: createAstroGlobFn()
+    // TODO: throw in Astro 7
+    get site() {
+      console.warn(
+        `Astro.site inside getStaticPaths is deprecated and will be removed in a future major version of Astro. Use import.meta.env.SITE instead`
+      );
+      return site ? new URL(site) : void 0;
+    },
+    // TODO: throw in Astro 7
+    get generator() {
+      console.warn(
+        `Astro.generator inside getStaticPaths is deprecated and will be removed in a future major version of Astro.`
+      );
+      return ASTRO_GENERATOR;
+    },
+    get callAction() {
+      throw createError("callAction");
+    },
+    get clientAddress() {
+      throw createError("clientAddress");
+    },
+    get cookies() {
+      throw createError("cookies");
+    },
+    get csp() {
+      throw createError("csp");
+    },
+    get currentLocale() {
+      throw createError("currentLocale");
+    },
+    get getActionResult() {
+      throw createError("getActionResult");
+    },
+    get isPrerendered() {
+      throw createError("isPrerendered");
+    },
+    get locals() {
+      throw createError("locals");
+    },
+    get originPathname() {
+      throw createError("originPathname");
+    },
+    get params() {
+      throw createError("params");
+    },
+    get preferredLocale() {
+      throw createError("preferredLocale");
+    },
+    get preferredLocaleList() {
+      throw createError("preferredLocaleList");
+    },
+    get props() {
+      throw createError("props");
+    },
+    get redirect() {
+      throw createError("redirect");
+    },
+    get request() {
+      throw createError("request");
+    },
+    get response() {
+      throw createError("response");
+    },
+    get rewrite() {
+      throw createError("rewrite");
+    },
+    get routePattern() {
+      throw createError("routePattern");
+    },
+    get self() {
+      throw createError("self");
+    },
+    get slots() {
+      throw createError("slots");
+    },
+    get url() {
+      throw createError("url");
+    },
+    get session() {
+      throw createError("session");
+    }
   };
 }
 export {

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

@@ -25,10 +25,7 @@ function astroTransitions({ settings }) {
         return {
           code: `
 						export * from "astro/virtual-modules/transitions.js";
-						export {
-							default as ViewTransitions,
-							default as ClientRouter
-						} from "astro/components/ClientRouter.astro";
+						export { default as ClientRouter } from "astro/components/ClientRouter.astro";
 					`
         };
       }

package/dist/types/astro.d.ts

@@ -4,7 +4,7 @@ import type { TSConfig } from '../core/config/tsconfig.js';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroPreferences } from '../preferences/index.js';
 import type { AstroComponentFactory } from '../runtime/server/index.js';
-import type { GetStaticPathsOptions, GetStaticPathsResult } from './public/common.js';
+import type { GetStaticPaths } from './public/common.js';
 import type { AstroConfig } from './public/config.js';
 import type { ContentEntryType, DataEntryType } from './public/content.js';
 import type { AstroAdapter, AstroRenderer, InjectedScriptStage, InjectedType } from './public/integrations.js';
@@ -75,7 +75,7 @@ export interface ComponentInstance {
     css?: string[];
     partial?: boolean;
     prerender?: boolean;
-    getStaticPaths?: (options: GetStaticPathsOptions) => GetStaticPathsResult;
+    getStaticPaths?: GetStaticPaths;
 }
 export interface RoutesList {
     routes: RouteData[];

package/dist/types/public/common.d.ts

@@ -11,9 +11,7 @@ export interface GetStaticPathsOptions {
     routePattern: string;
 }
 export type GetStaticPathsItem = {
-    params: {
-        [K in keyof Params]: Params[K] | number;
-    };
+    params: Params;
     props?: Props;
 };
 export type GetStaticPathsResult = GetStaticPathsItem[];