astro 3.4.4 → 3.5.0

package/dist/core/endpoint/index.js

@@ -4,6 +4,8 @@ import { ASTRO_VERSION } from "../constants.js";
 import { AstroCookies, attachCookiesToResponse } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { callMiddleware } from "../middleware/callMiddleware.js";
+import { computePreferredLocale, computePreferredLocaleList } from "../render/context.js";
+import {} from "../render/index.js";
 const encoder = new TextEncoder();
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = Symbol.for("astro.locals");
@@ -12,8 +14,11 @@ function createAPIContext({
   params,
   site,
   props,
-  adapterName
+  adapterName,
+  locales
 }) {
+  let preferredLocale = void 0;
+  let preferredLocaleList = void 0;
   const context = {
     cookies: new AstroCookies(request),
     request,
@@ -30,6 +35,26 @@ function createAPIContext({
       });
     },
     ResponseWithEncoding,
+    get preferredLocale() {
+      if (preferredLocale) {
+        return preferredLocale;
+      }
+      if (locales) {
+        preferredLocale = computePreferredLocale(request, locales);
+        return preferredLocale;
+      }
+      return void 0;
+    },
+    get preferredLocaleList() {
+      if (preferredLocaleList) {
+        return preferredLocaleList;
+      }
+      if (locales) {
+        preferredLocaleList = computePreferredLocaleList(request, locales);
+        return preferredLocaleList;
+      }
+      return void 0;
+    },
     url: new URL(request.url),
     get clientAddress() {
       if (clientAddressSymbol in request) {
@@ -81,13 +106,14 @@ class ResponseWithEncoding extends Response {
     }
   }
 }
-async function callEndpoint(mod, env, ctx, onRequest) {
+async function callEndpoint(mod, env, ctx, onRequest, locales) {
   const context = createAPIContext({
     request: ctx.request,
     params: ctx.params,
     props: ctx.props,
     site: env.site,
-    adapterName: env.adapterName
+    adapterName: env.adapterName,
+    locales
   });
   let response;
   if (onRequest) {

package/dist/core/errors/errors-data.d.ts

@@ -1139,6 +1139,17 @@ export declare const UnsupportedConfigTransformError: {
     message: (parseError: string) => string;
     hint: string;
 };
+export declare const MissingLocale: {
+    name: string;
+    title: string;
+    message: (locale: string, locales: string[]) => string;
+};
+export declare const CantRenderPage: {
+    name: string;
+    title: string;
+    message: string;
+    hint: string;
+};
 export declare const UnknownError: {
     name: string;
     title: string;

package/dist/core/errors/errors-data.js

@@ -426,11 +426,27 @@ const UnsupportedConfigTransformError = {
 Full error: ${parseError}`,
   hint: "See the devalue library for all supported types: https://github.com/rich-harris/devalue"
 };
+const MissingLocale = {
+  name: "MissingLocaleError",
+  title: "The provided locale does not exist.",
+  message: (locale, locales) => {
+    return `The locale \`${locale}\` does not exist in the configured locales. Available locales: ${locales.join(
+      ", "
+    )}.`;
+  }
+};
+const CantRenderPage = {
+  name: "CantRenderPage",
+  title: "Astro can't render the route.",
+  message: "Astro cannot find any content to render for this route. There is no file or redirect associated with this route.",
+  hint: "If you expect to find a route here, this may be an Astro bug. Please file an issue/restart the dev server"
+};
 const UnknownError = { name: "UnknownError", title: "Unknown Error." };
 export {
   AstroGlobNoMatch,
   AstroGlobUsedOutside,
   CSSSyntaxError,
+  CantRenderPage,
   ClientAddressNotAvailable,
   CollectionDoesNotExistError,
   ConfigLegacyKey,
@@ -470,6 +486,7 @@ export {
   MiddlewareNoDataOrNextCalled,
   MiddlewareNotAResponse,
   MissingImageDimension,
+  MissingLocale,
   MissingMediaQueryDirective,
   MissingSharp,
   MixedContentDataCollectionError,

package/dist/core/messages.js

@@ -50,7 +50,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "3.4.4";
+  const version = "3.5.0";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -235,7 +235,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"3.4.4"}`
+        `v${"3.5.0"}`
       )} ${headline}`
     );
   }

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

@@ -1,6 +1,6 @@
-import type { MiddlewareResponseHandler, Params } from '../../@types/astro.js';
+import type { MiddlewareEndpointHandler, Params } from '../../@types/astro.js';
 import { sequence } from './sequence.js';
-declare function defineMiddleware(fn: MiddlewareResponseHandler): MiddlewareResponseHandler;
+declare function defineMiddleware(fn: MiddlewareEndpointHandler): MiddlewareEndpointHandler;
 /**
  * Payload for creating a context to be passed to Astro middleware
  */
@@ -13,11 +13,15 @@ export type CreateContext = {
      * Optional parameters
      */
     params?: Params;
+    /**
+     * A list of locales that are supported by the user
+     */
+    userDefinedLocales?: string[];
 };
 /**
  * Creates a context to be passed to Astro middleware `onRequest` function.
  */
-declare function createContext({ request, params }: CreateContext): import("../../@types/astro.js").APIContext<Record<string, any>, Record<string, string | undefined>>;
+declare function createContext({ request, params, userDefinedLocales }: CreateContext): import("../../@types/astro.js").APIContext<Record<string, any>, Record<string, string | undefined>>;
 /**
  * It attempts to serialize `value` and return it as a string.
  *

package/dist/core/middleware/index.js

@@ -3,12 +3,13 @@ import { sequence } from "./sequence.js";
 function defineMiddleware(fn) {
   return fn;
 }
-function createContext({ request, params }) {
+function createContext({ request, params, userDefinedLocales = [] }) {
   return createAPIContext({
     request,
     params: params ?? {},
     props: {},
-    site: void 0
+    site: void 0,
+    locales: userDefinedLocales
   });
 }
 function isLocalsSerializable(value) {

package/dist/core/middleware/loadMiddleware.d.ts

@@ -1,8 +1,7 @@
-import type { AstroSettings } from '../../@types/astro.js';
 import type { ModuleLoader } from '../module-loader/index.js';
 /**
  * It accepts a module loader and the astro settings, and it attempts to load the middlewares defined in the configuration.
  *
  * If not middlewares were not set, the function returns an empty array.
  */
-export declare function loadMiddleware(moduleLoader: ModuleLoader, srcDir: AstroSettings['config']['srcDir']): Promise<Record<string, any> | undefined>;
+export declare function loadMiddleware(moduleLoader: ModuleLoader): Promise<Record<string, any> | undefined>;

package/dist/core/middleware/loadMiddleware.js

@@ -1,8 +1,7 @@
-import { MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
-async function loadMiddleware(moduleLoader, srcDir) {
-  let middlewarePath = `${decodeURI(srcDir.pathname)}${MIDDLEWARE_PATH_SEGMENT_NAME}`;
+import { MIDDLEWARE_MODULE_ID } from "./vite-plugin.js";
+async function loadMiddleware(moduleLoader) {
   try {
-    const module = await moduleLoader.import(middlewarePath);
+    const module = await moduleLoader.import(MIDDLEWARE_MODULE_ID);
     return module;
   } catch {
     return void 0;

package/dist/core/middleware/sequence.d.ts

@@ -1,6 +1,6 @@
-import type { MiddlewareResponseHandler } from '../../@types/astro.js';
+import type { MiddlewareEndpointHandler } from '../../@types/astro.js';
 /**
  *
  * It accepts one or more middleware handlers and makes sure that they are run in sequence.
  */
-export declare function sequence(...handlers: MiddlewareResponseHandler[]): MiddlewareResponseHandler;
+export declare function sequence(...handlers: MiddlewareEndpointHandler[]): MiddlewareEndpointHandler;

package/dist/core/middleware/sequence.js

@@ -1,6 +1,7 @@
 import { defineMiddleware } from "./index.js";
 function sequence(...handlers) {
-  const length = handlers.length;
+  const filtered = handlers.filter((h) => !!h);
+  const length = filtered.length;
   if (!length) {
     const handler = defineMiddleware((context, next) => {
       return next();
@@ -10,7 +11,7 @@ function sequence(...handlers) {
   return defineMiddleware((context, next) => {
     return applyHandle(0, context);
     function applyHandle(i, handleContext) {
-      const handle = handlers[i];
+      const handle = filtered[i];
       const result = handle(handleContext, async () => {
         if (i < length - 1) {
           return applyHandle(i + 1, handleContext);

package/dist/core/middleware/vite-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../@types/astro.js';
+import type { BuildInternals } from '../build/internal.js';
+import type { StaticBuildOptions } from '../build/types.js';
+export declare const MIDDLEWARE_MODULE_ID = "@astro-middleware";
+export declare function vitePluginMiddleware({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;
+export declare function vitePluginMiddlewareBuild(opts: StaticBuildOptions, internals: BuildInternals): VitePlugin;

package/dist/core/middleware/vite-plugin.js

@@ -0,0 +1,101 @@
+import { normalizePath } from "vite";
+import { getOutputDirectory } from "../../prerender/utils.js";
+import { addRollupInput } from "../build/add-rollup-input.js";
+import { MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
+const MIDDLEWARE_MODULE_ID = "@astro-middleware";
+const EMPTY_MIDDLEWARE = "\0empty-middleware";
+function vitePluginMiddleware({ settings }) {
+  let isCommandBuild = false;
+  let resolvedMiddlewareId = void 0;
+  const hasIntegrationMiddleware = settings.middlewares.pre.length > 0 || settings.middlewares.post.length > 0;
+  return {
+    name: "@astro/plugin-middleware",
+    config(opts, { command }) {
+      isCommandBuild = command === "build";
+      return opts;
+    },
+    async resolveId(id) {
+      if (id === MIDDLEWARE_MODULE_ID) {
+        const middlewareId = await this.resolve(
+          `${decodeURI(settings.config.srcDir.pathname)}${MIDDLEWARE_PATH_SEGMENT_NAME}`
+        );
+        if (middlewareId) {
+          resolvedMiddlewareId = middlewareId.id;
+          return MIDDLEWARE_MODULE_ID;
+        } else if (hasIntegrationMiddleware) {
+          return MIDDLEWARE_MODULE_ID;
+        } else {
+          return EMPTY_MIDDLEWARE;
+        }
+      }
+      if (id === EMPTY_MIDDLEWARE) {
+        return EMPTY_MIDDLEWARE;
+      }
+    },
+    async load(id) {
+      if (id === EMPTY_MIDDLEWARE) {
+        return "export const onRequest = undefined";
+      } else if (id === MIDDLEWARE_MODULE_ID) {
+        if (isCommandBuild) {
+          this.emitFile({
+            type: "chunk",
+            preserveSignature: "strict",
+            fileName: "middleware.mjs",
+            id
+          });
+        }
+        const preMiddleware = createMiddlewareImports(settings.middlewares.pre, "pre");
+        const postMiddleware = createMiddlewareImports(settings.middlewares.post, "post");
+        const source = `
+import { onRequest as userOnRequest } from '${resolvedMiddlewareId}';
+import { sequence } from 'astro:middleware';
+${preMiddleware.importsCode}${postMiddleware.importsCode}
+
+export const onRequest = sequence(
+	${preMiddleware.sequenceCode}${preMiddleware.sequenceCode ? "," : ""}
+	userOnRequest${postMiddleware.sequenceCode ? "," : ""}
+	${postMiddleware.sequenceCode}
+);
+`.trim();
+        return source;
+      }
+    }
+  };
+}
+function createMiddlewareImports(entrypoints, prefix) {
+  let importsRaw = "";
+  let sequenceRaw = "";
+  let index = 0;
+  for (const entrypoint of entrypoints) {
+    const name = `_${prefix}_${index}`;
+    importsRaw += `import { onRequest as ${name} } from '${normalizePath(entrypoint)}';
+`;
+    sequenceRaw += `${index > 0 ? "," : ""}${name}`;
+    index++;
+  }
+  return {
+    importsCode: importsRaw,
+    sequenceCode: sequenceRaw
+  };
+}
+function vitePluginMiddlewareBuild(opts, internals) {
+  return {
+    name: "@astro/plugin-middleware-build",
+    options(options) {
+      return addRollupInput(options, [MIDDLEWARE_MODULE_ID]);
+    },
+    writeBundle(_, bundle) {
+      for (const [chunkName, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "asset" && chunk.fileName === "middleware.mjs") {
+          const outputDirectory = getOutputDirectory(opts.settings.config);
+          internals.middlewareEntryPoint = new URL(chunkName, outputDirectory);
+        }
+      }
+    }
+  };
+}
+export {
+  MIDDLEWARE_MODULE_ID,
+  vitePluginMiddleware,
+  vitePluginMiddlewareBuild
+};

package/dist/core/pipeline.d.ts

@@ -36,6 +36,6 @@ export declare class Pipeline {
     /**
      * The main function of the pipeline. Use this function to render any route known to Astro;
      */
-    renderRoute(renderContext: RenderContext, componentInstance: ComponentInstance): Promise<Response>;
+    renderRoute(renderContext: RenderContext, componentInstance: ComponentInstance | undefined): Promise<Response>;
 }
 export {};

package/dist/core/pipeline.js

@@ -82,10 +82,12 @@ class Pipeline {
       params: renderContext.params,
       props: renderContext.props,
       site: env.site,
-      adapterName: env.adapterName
+      adapterName: env.adapterName,
+      locales: renderContext.locales
     });
     switch (renderContext.route.type) {
       case "page":
+      case "fallback":
       case "redirect": {
         if (onRequest) {
           return await callMiddleware(
@@ -111,13 +113,13 @@ class Pipeline {
         }
       }
       case "endpoint": {
-        const result = await callEndpoint(
+        return await callEndpoint(
           mod,
           env,
           renderContext,
-          onRequest
+          onRequest,
+          renderContext.locales
         );
-        return result;
       }
       default:
         throw new Error(`Couldn't find route of type [${renderContext.route.type}]`);

package/dist/core/redirects/helpers.d.ts

@@ -1,4 +1,5 @@
 import type { Params, RedirectRouteData, RouteData, ValidRedirectStatus } from '../../@types/astro.js';
 export declare function routeIsRedirect(route: RouteData | undefined): route is RedirectRouteData;
+export declare function routeIsFallback(route: RouteData | undefined): route is RedirectRouteData;
 export declare function redirectRouteGenerate(redirectRoute: RouteData, data: Params): string;
 export declare function redirectRouteStatus(redirectRoute: RouteData, method?: string): ValidRedirectStatus;

package/dist/core/redirects/helpers.js

@@ -1,6 +1,9 @@
 function routeIsRedirect(route) {
   return route?.type === "redirect";
 }
+function routeIsFallback(route) {
+  return route?.type === "fallback";
+}
 function redirectRouteGenerate(redirectRoute, data) {
   const routeData = redirectRoute.redirectRoute;
   const route = redirectRoute.redirect;
@@ -25,5 +28,6 @@ function redirectRouteStatus(redirectRoute, method = "GET") {
 export {
   redirectRouteGenerate,
   redirectRouteStatus,
+  routeIsFallback,
   routeIsRedirect
 };

package/dist/core/render/context.d.ts

@@ -15,11 +15,34 @@ export interface RenderContext {
     params: Params;
     props: Props;
     locals?: object;
+    locales: string[] | undefined;
 }
 export type CreateRenderContextArgs = Partial<Omit<RenderContext, 'params' | 'props' | 'locals'>> & {
     route: RouteData;
     request: RenderContext['request'];
-    mod: ComponentInstance;
+    mod: ComponentInstance | undefined;
     env: Environment;
 };
 export declare function createRenderContext(options: CreateRenderContextArgs): Promise<RenderContext>;
+type BrowserLocale = {
+    locale: string;
+    qualityValue: number | undefined;
+};
+/**
+ * Parses the value of the `Accept-Header` language:
+ *
+ * More info: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language
+ *
+ * Complex example: `fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5`
+ *
+ */
+export declare function parseLocale(header: string): BrowserLocale[];
+/**
+ * Set the current locale by parsing the value passed from the `Accept-Header`.
+ *
+ * If multiple locales are present in the header, they are sorted by their quality value and the highest is selected as current locale.
+ *
+ */
+export declare function computePreferredLocale(request: Request, locales: string[]): string | undefined;
+export declare function computePreferredLocaleList(request: Request, locales: string[]): string[];
+export {};

package/dist/core/render/context.js

@@ -1,3 +1,4 @@
+import { normalizeTheLocale } from "../../i18n/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { getParamsAndProps } from "./params-and-props.js";
 const clientLocalsSymbol = Symbol.for("astro.locals");
@@ -16,7 +17,8 @@ async function createRenderContext(options) {
     ...options,
     pathname,
     params,
-    props
+    props,
+    locales: options.locales
   };
   Object.defineProperty(context, "locals", {
     enumerable: true,
@@ -33,6 +35,98 @@ async function createRenderContext(options) {
   });
   return context;
 }
+function parseLocale(header) {
+  if (header === "*") {
+    return [{ locale: header, qualityValue: void 0 }];
+  }
+  const result = [];
+  const localeValues = header.split(",").map((str) => str.trim());
+  for (const localeValue of localeValues) {
+    const split = localeValue.split(";").map((str) => str.trim());
+    const localeName = split[0];
+    const qualityValue = split[1];
+    if (!split) {
+      continue;
+    }
+    if (qualityValue && qualityValue.startsWith("q=")) {
+      const qualityValueAsFloat = Number.parseFloat(qualityValue.slice("q=".length));
+      if (Number.isNaN(qualityValueAsFloat) || qualityValueAsFloat > 1) {
+        result.push({
+          locale: localeName,
+          qualityValue: void 0
+        });
+      } else {
+        result.push({
+          locale: localeName,
+          qualityValue: qualityValueAsFloat
+        });
+      }
+    } else {
+      result.push({
+        locale: localeName,
+        qualityValue: void 0
+      });
+    }
+  }
+  return result;
+}
+function sortAndFilterLocales(browserLocaleList, locales) {
+  const normalizedLocales = locales.map(normalizeTheLocale);
+  return browserLocaleList.filter((browserLocale) => {
+    if (browserLocale.locale !== "*") {
+      return normalizedLocales.includes(normalizeTheLocale(browserLocale.locale));
+    }
+    return true;
+  }).sort((a, b) => {
+    if (a.qualityValue && b.qualityValue) {
+      if (a.qualityValue > b.qualityValue) {
+        return -1;
+      } else if (a.qualityValue < b.qualityValue) {
+        return 1;
+      }
+    }
+    return 0;
+  });
+}
+function computePreferredLocale(request, locales) {
+  const acceptHeader = request.headers.get("Accept-Language");
+  let result = void 0;
+  if (acceptHeader) {
+    const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
+    const firstResult = browserLocaleList.at(0);
+    if (firstResult) {
+      if (firstResult.locale !== "*") {
+        result = locales.find(
+          (locale) => normalizeTheLocale(locale) === normalizeTheLocale(firstResult.locale)
+        );
+      }
+    }
+  }
+  return result;
+}
+function computePreferredLocaleList(request, locales) {
+  const acceptHeader = request.headers.get("Accept-Language");
+  let result = [];
+  if (acceptHeader) {
+    const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
+    if (browserLocaleList.length === 1 && browserLocaleList.at(0).locale === "*") {
+      return locales;
+    } else if (browserLocaleList.length > 0) {
+      for (const browserLocale of browserLocaleList) {
+        const found = locales.find(
+          (l) => normalizeTheLocale(l) === normalizeTheLocale(browserLocale.locale)
+        );
+        if (found) {
+          result.push(found);
+        }
+      }
+    }
+  }
+  return result;
+}
 export {
-  createRenderContext
+  computePreferredLocale,
+  computePreferredLocaleList,
+  createRenderContext,
+  parseLocale
 };

package/dist/core/render/core.d.ts

@@ -1,22 +1,10 @@
-import type { AstroCookies, ComponentInstance, MiddlewareHandler } from '../../@types/astro.js';
+import type { AstroCookies, ComponentInstance } from '../../@types/astro.js';
 import type { RenderContext } from './context.js';
 import type { Environment } from './environment.js';
 export type RenderPage = {
-    mod: ComponentInstance;
+    mod: ComponentInstance | undefined;
     renderContext: RenderContext;
     env: Environment;
     cookies: AstroCookies;
 };
 export declare function renderPage({ mod, renderContext, env, cookies }: RenderPage): Promise<Response>;
-/**
- * It attempts to render a route. A route can be a:
- * - page
- * - redirect
- * - endpoint
- *
- * ## Errors
- *
- * It throws an error if the page can't be rendered.
- * @deprecated Use the pipeline instead
- */
-export declare function tryRenderRoute<MiddlewareReturnType = Response>(renderContext: Readonly<RenderContext>, env: Readonly<Environment>, mod: Readonly<ComponentInstance>, onRequest?: MiddlewareHandler<MiddlewareReturnType>): Promise<Response>;

package/dist/core/render/core.js

@@ -1,7 +1,8 @@
 import { renderPage as runtimeRenderPage } from "../../runtime/server/index.js";
 import { attachCookiesToResponse } from "../cookies/index.js";
-import { callEndpoint, createAPIContext } from "../endpoint/index.js";
-import { callMiddleware } from "../middleware/callMiddleware.js";
+import { CantRenderPage } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
+import { routeIsFallback } from "../redirects/helpers.js";
 import { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from "../redirects/index.js";
 import { createResult } from "./result.js";
 async function renderPage({ mod, renderContext, env, cookies }) {
@@ -12,6 +13,12 @@ async function renderPage({ mod, renderContext, env, cookies }) {
         location: redirectRouteGenerate(renderContext.route, renderContext.params)
       }
     });
+  } else if (routeIsFallback(renderContext.route)) {
+    return new Response(null, {
+      status: 404
+    });
+  } else if (!mod) {
+    throw new AstroError(CantRenderPage);
   }
   const Component = mod.default;
   if (!Component)
@@ -35,7 +42,8 @@ async function renderPage({ mod, renderContext, env, cookies }) {
     ssr: env.ssr,
     status: renderContext.status ?? 200,
     cookies,
-    locals: renderContext.locals ?? {}
+    locals: renderContext.locals ?? {},
+    locales: renderContext.locales
   });
   if (mod.frontmatter && typeof mod.frontmatter === "object" && "draft" in mod.frontmatter) {
     env.logger.warn(
@@ -56,54 +64,6 @@ async function renderPage({ mod, renderContext, env, cookies }) {
   }
   return response;
 }
-async function tryRenderRoute(renderContext, env, mod, onRequest) {
-  const apiContext = createAPIContext({
-    request: renderContext.request,
-    params: renderContext.params,
-    props: renderContext.props,
-    site: env.site,
-    adapterName: env.adapterName
-  });
-  switch (renderContext.route.type) {
-    case "page":
-    case "redirect": {
-      if (onRequest) {
-        return await callMiddleware(
-          env.logger,
-          onRequest,
-          apiContext,
-          () => {
-            return renderPage({
-              mod,
-              renderContext,
-              env,
-              cookies: apiContext.cookies
-            });
-          }
-        );
-      } else {
-        return await renderPage({
-          mod,
-          renderContext,
-          env,
-          cookies: apiContext.cookies
-        });
-      }
-    }
-    case "endpoint": {
-      const result = await callEndpoint(
-        mod,
-        env,
-        renderContext,
-        onRequest
-      );
-      return result;
-    }
-    default:
-      throw new Error(`Couldn't find route of type [${renderContext.route.type}]`);
-  }
-}
 export {
-  renderPage,
-  tryRenderRoute
+  renderPage
 };